1. 构造函数：

是一种特殊的函数，没有返回值。

构造函数的名称与类的名称相同。

一般用于初始化成员变量的值。

使用super关键字来调用父类的构造函数。

2. 方法的重载：

法名相同但参数的个数或类型不同，一般情况下是在一个类中定义的，其实现

的方法是相似的。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数

或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改

变返回值的类型。

3 方法的重写：

原型相同，即名称，参数的个数及类型相同，一般用于类继承中子类继承父类的

方法。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写

(Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中

的定义如同被"屏蔽"了。

4 两者的区别：

方法的重写Overriding和重载Overloading是Java多态性的不同表现。

重写Overriding是父类与子类之间多态性的一种表现。（继承）

重载Overloading是一个类中多态性的一种表现。（一个类中）

5. 抽象类：

抽象方法是在申明方法的部分加入abstract 关键字，是没有方法体的。如果一个类中

有抽象方法，则该类必须声明为抽象类。一个抽象类可以有抽象的方法也可以没有抽

象方法。它不能实例化，一般体现在继承中。一个类继承了抽象类，如果没有实现抽

象类中的方法，那么这个子类也必须声明为抽象类。抽象类可以实现(implements)

接口，抽象类可以继承实体类，但前提是实体类必须有明确的构造函数。

6. 接口：

由于Java不支持多继承，而有可能某个类或对象要使用分别在几个类或对象里

面的方法或属性，现有的单继承机制就不能满足要求。与继承相比，接口有更高的灵

活性，因为接口中没有任何实现代码。当一个类实现了接口以后，该类要实现接口里

面所有的方法和属性，并且接口里面的属性在默认状态下面都是public static,所有方

法默认情况下是public.一个类可以实现多个接口。

接口就是一套标准和规则。若要定义子类来实现接口，则子类就必须实现接口的

全部方法。

接口是一种特殊的抽象类，也不能被实例化。

接口可以继承接口。接口中只能声明方法和常量，不能定义方法和常量。

接口中的所有方法默认为 public abstract （即都是抽象的方法）

常量默认为public static final

7、 abstract class和interface有什么区别?

声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创

建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。

不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。

接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性

可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。

8 final修饰符：

Final 声明常量时：private static final 数据类型 常量名称=值

Final 声明方法时：子类不能重写final方法

Final 声明类时不能被继承

String类是final 的典型应用

9 static 修饰的方法：

static 可以修饰属性和方法

static 修饰的方法只能访问static修饰的静态属性和static修饰的静态方法 在调用属性时，可以用类和类对象来调用，但最好用类来调用。

10 .GOF面向对象设计模式：23种

Java中的23种设计模式：

Factory（工厂模式）， Builder（建造模式）， Factory Method（工厂方法模式）， Prototype（原始模型模式），Singleton（单例模式）， Facade（门面模式），

Adapter（适配器模式）， Bridge（桥梁模式）， Composite（合成模式）， Decorator（装饰模式）， Flyweight（享元模式）， Proxy（代理模式），

Command（命令模式）， Interpreter（解释器模式）， Visitor（访问者模式）， Iterator（迭代子模式）， Mediator（调停者模式）， Memento（备忘录模式）， Observer（观察者模式）， State（状态模式）， Strategy（策略模式）， Template Method（模板方法模式）， Chain Of Responsibleity（责任链模式）

工厂模式：工厂模式是一种经常被使用到的模式，根据工厂模式实现的类可以根据

提供的数据生成一组类中某一个类的实例，通常这一组类有一个公共的抽象父类并且实现了相同的方法，但是这些方法针对不同的数据进行了不同的操作。首先需要定义一个基类，该类的子类通过不同的方法实现了基类中的方法。然后需要定义一个工厂类，工厂类可以根据条件生成不同的子类实例。当得到子类的实例后，开发人员可以调用基类中的方法而不必考虑到底返回的是哪一个子类的实例。

11 Java 基本数据类型：

基本数据类型： 包括byte、int、char、long、float、double、long int 、short int、boolean和short。

java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer类。

引用类型： 通过new关键字来创建的类型

12 String 类方法、、、

1. 面向对象的特征有哪些方面

1.抽象：

抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。

2.继承：

继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。

3.封装：

封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。

只要有足够的方法，就没必要直接去操作对象属性，只要调用这些方法就可以实现要完成的任务，这种现象称为封装，它通过对象方法对其属性的操作把对象属性封装在一个对象内部，对象与外界打交道全部通过其自身的方法来实现，有效的把对象属性隐藏在对象内部。

4. 多态性：

多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

2. 什么是类与对象？

所谓对象就是真实世界中的实体，对象与实体是一一对应的，也就是说现实世界中每一个实体都是一个对象，它是一种具体的概念。

类是具备某些共同特征的实体的集合，它是一种抽象的概念，用程序设计的语言来说，类是一种抽象的数据类型，它是对所具有相同特征实体的抽象。

3. 什么是属性与方法？

不同对象具有相同特点，就可能抽象为一定的类，那么这些特点基本上可以分为两类，一类是描述对象静态状态的，就是对象的属性，在程序设计中，可以称之为变 量；另一类是描述对象的动作，就是对象的方法，在程序设计中我们称之为函数。属性和方法是一个对象所具备的两大基本要素，也是我们后面编程工作的核心。

4. int 和 Integer 有什么区别

Java 提供两种不同的类型：引用类型和原始类型（或内置类型）。Int是java的原始数据类型，Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。

原始类型封装类

boolean Boolean

char Character

byte Byte

short Short

int Integer

long Long

float Float

double Double

引用类型和原始类型的行为完全不同，并且它们具有不同的语义。引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null，而原始类型实例变量的缺省值与它们的类型有关。

5. String 和StringBuffer的区别（还有StringBuilder）

JAVA平台提供了两个 类：String和StringBuffer，它们可以储存和操作字符串，即包含多个字符的字符数据。这个String类提供了数值不可改变的字符串。而 这个StringBuffer类提供的字符串进行修改。当你知道字符数据要改变的时候你就可以使用StringBuffer。典型地，你可以使用 StringBuffers来动态构造字符数据。

 

第二篇：Java总结

Java总结

一．1.Java程序的执行

Java先由.Java文件编译生成.class文件，再由.class文件通过不同操作系统的虚拟机进行解释从而执行程序结果。

编译命令： javac + 文件名.Java 解释命令：java + 文件名(区分大小写)

2.环境变量的设置

把安装好的jdk的bin文件夹的路径复制到我的电脑中属性的环境变量中。

二．1.面向对象编程的思维

类-->对象-->属性、方法

2.类，方法，属性的创建

创建类即利用关键字class + 类名{}。创建方法要包括此方法的类型(public 默认 protected private)，返回值类型，方法名，参数，方法体，其中构造方法是方法名和类名相同的一种方法。

3.对象的创建

创建某个类的对象就是要调用这个类的构造方法(new 构造方法)，如果编程没有明确写出某个类的的构造方法，系统则自动提供一个无参的，且方法体为空的构造方法。

4.调用对象的方法或属性

对象名.方法 对象名.属性

三．1.java标识符命名

首字母必须是字母，_或$符号，其他字符可以是字母，数字，_或者$。

2.数据类型

简单数据类型：

布尔boolean：1位，取值为true，false

字符char：2字节，单引号’ ’括起来的单个字符

数值：整数：byte 1字节

short 2字节

int 4字节

long 8字节

浮点数：float 4字节，数字后面需加f

double 8字节

复核数据类型：类class，接口interface，数组[]

3.包

包的命名 package 域名.系统名.模块名.其他名

包的导入 import java.util.*；

四．1.变量

全局变量 在类中定义在整个类中都可以使用

局部变量 在方法内部定义、方法的形参、游离块内部定义

五．1.运算符

算术运算符：+ - * / % ++ --

关系运算符：> < >= <= == !=

逻辑运算符：! && || ^

位运算符：& | >> << ^(按位亦或) ~(取反)

赋值运算符：=

字符串连接：+

2.短路逻辑运算符：由一个操作数能判断出结果则不再判断第二个操作数

3.数据类型转换

byte->short char->int->long float->double int->float long->double

强制类型转换 类型 变量名 = (类型) 值;

4.三目运算符 x ? y : z 判断表达式x的值，若true则整个表达式的值为y，反之为z

5.程序结构

顺序结构、选择结构、循环结构

6.分支语句

If else语句：if( ){ }else{ }

Switch语句：switch( ){case’A’:…break;case2：…break;…;default:…break;}

7.循环语句

do{循环体}while(条件) while(条件){循环体} for( ; ; ){循环体}

8.break语句跳出整个循环 continue语句结束本轮循环

六．数组

1.数组声明

类型[] 数组名; 或 类型 数组名[];

2.数组创建

数组名 = new 类型[n];

3.声明同时创建

类型[] 数组名= new 类型[n]; eg: int[] a= new int[10];

4.数组赋初值

在声明的同时赋值 eg：int a[]={1,2,3};

在声明之后赋值，只能使用循环一个一个赋值

5.数组引用从0开始计数，长度可以通过 数组属性length获得(数组名.length)

6.排序

冒泡排序：循环遍历数组，一次比较两个元素，如果他们的顺序错误就把他们交换过来，直到无需交换完成排序。

int[] a;

int temp = 0;

for (int i = a.length - 1; i > 0; --i) {

for (int j = 0; j < i; ++j) {

if (a[j + 1] < a[j]) {

temp = a[j];

a[j] = a[j + 1];

a[j + 1] = temp;

}

}

}

直接调用数组静态方法sort eg：Arrays.sort(a);

7.数组的复制，调用System.arraycopy()

System.arraycopy(a, 0, b, 0, a.length);从a中0开始复制到b中0开始，长度为a的长度

8.多维数组

int[][] a;

int[][] a= new int[n][];

七．1.类的继承(仅单继承)

class B extends A{} 其中父类的属性，一般方法，内部内都要被继承，构造方法不能继承。

2.方法重载

方法名相同，参数列表必须不同。

3.方法重写

在类继承的基础上方法名，参数列表，返回值类型都相同，修饰符更加宽松，构造方法不能重写

4.调用父类方法或属性super.方法，super.属性，调用本类中其他方法或属性this.方法，this.属性

八．1.==与equals();

==判断是否指向同一对象，equals();判断内容是否相同

2.static可以就是属性，一般方法，游离块，内部类，不能修饰构造方法

3.静态属性被该类的所有对象共享，用 类名.静态属性 类名.静态方法 进行调用。静态方法中不能使用非静态属性和方法。

4.单子设计模式

5.final修饰类，方法，属性

final类不能被继承，final变量初始化后不可改变，final方法不能重写

6.抽象abstract类无法实例化，abstract方法无方法体

7.接口interface，实现接口 ： class 类名 implements 接口名{}

8.多态 eg：父类 对象名 = new 子类()；发生的情况：1)继承;2)接口的实现。

九．1.异常处理的格式

try{可能出现异常的代码段}

catch(MyException mye){mye异常抛出时执行的代码段 }

catch(Exception e){e.printStackTrace();}

finally{必定要执行的语句}

2.throws在方法头，用于标明该方法可能抛出的所有异常。

3.throw在方法体中，用来抛出一个异常，结合try—catch语句使用。

4.自定义异常

通过继承Exception类实现自定义

先继承Exception类自定义异常，再执行程序中try抛出此异常，catch捕获处理 十．1.String类(String不可变)

相关的方法charAt，toCharArray，length，indexOf，trim，substring，toUpperCase，startWith，equals，equalsIgnoreCase， replaceAll，split

2.StringBuffer：同步的(线程安全)可变字符串；StringBuilder非同步的(线程不安全)可变字符串。常用方法append，reverse，replace，toString

3.日期类

Calendar cal = new GregorianCalendar();

int year=cal.get(Calendar.YEAR);

Calendar c = Calendar.getInstance();

int year = c.get(Calendar.YEAR);

4.Math类

常用方法round，random(随机生成大于等于0，小于1的数字)

5.Random类nextInt(n)方法，随机生成0到n的整数

6.TimerTask类，其中的run()方法写出要执行的代码，在实例化Timer和TimerTask，用Timer对象的schedule方法执行TimerTask的对象。

十一.1.List集合,可重复有序集合

List<泛型> 集合名 = new ArrayList<泛型>();

构造时用到了多态，用ArrayList类实现了List接口。

常用方法add，size，clear等，循环遍历

2.Set集合，不可重复无序集合

Set<泛型> = new HashSet<泛型>()；

构造时用HashSet类实现了Set接口。

常用方法add，clear，size等，循环遍历

Set可以过滤重复元素

3.使用Set过滤List中的重复元素，在构造Set对象时把List对象当作参数传入

4.Map集合key---values，key不可重复

Map<String,String>map = new Hashtable<String，String>()；

构造是用Hashtable类实现了Map接口。

常用方法put，get，keyset，values，size，循环遍历

5.HashMap异步处理，性能高，非线程安全

Hashtable同步处理，性能低，线程安全

十二.1.File类

File f = new File(“文件地址”);

常用方法createNewFile,exists,delete,mkdir(创建文件夹),listFiles(列出文件夹内容)

2.字符流

InputStream input = new FileInputStream(f);

OutputStream output new FileOutputStream(f,true);

用FileInputStream(FileOutputStream)类实例化抽象类InputStream(OutputStream)类，将File对象f当作参数传入为操作对象。

输出方法byte b[] = new byte[1024];input.read(b);input.close(b);

输入方法byte b[] = str.getBytes();out.write(b);out.close();

3.字节流

Reader input = new FileReader(f);

Writer output = new FileWriter(f);

用FileReader(FileWriter)类实例化抽象类Reader(Writer)类，将File对象f当作参数传入为操作对象。

输出read()方法，输入write()方法

4.打印流

PrintStream ps = new PrintStream(new FileOutputStream(new File("地址")));

输入方法println(“str”);

5.BufferedReader

buf = new BufferedReader(new FileReader(new File("地址")));

输出方法readLine()；

以上方式均用try—catch包围，并且使用完要关闭流

十三.1.通过继承Thread类构造线程，其中要重写run()方法，若要间隔调用可使用Thread

的静态方法sleep()；调用线程时先实例化自定义的类，再调用此对象的start()方法

2.通过构造类实现Runnable接口，其中重写run()方法，若要间隔调用可使用Thread的

静态方法sleep()；调用线程时，先实例化上述Runnable生成的类，再实例化Thread类，并把Runnable对象当作参数传入，start()方法执行线程。

3.互斥锁，通过synchronized (this)包围目标代码或synchronized void 方法名(){}，实现线

程间的互斥操作。

十四.1.容器JFrame

2.组件JButten，JLabel，JTextField，JPanel，JTextArea

3.常用方法add，setVisible，setLocation，pack

4.布局管理

5.事件处理

建立按钮和事件处理者的关系;注册监听；通过实现ActionListener接口构造内部类:委托

式事件处理。