T-2-java面向对象

一、类

1. 类对象的数据结构定义，方法是对象的行为。
2. 类是数据类型。
3. 一个类可以创建多个对象，这多个对象结构相同，数据不同。
4. 类中可以包含：（1）成员变量（对象的共同特征，静的）；（2）方法（对象的共同行为，动的，常常用作操作成员变量）
5. 一个.java文件可以包含多个类，但是public的类只能有一个，并且这个类的名字必须和文件的名字一样，实际编码中建议一个文件只放一个类。

 

二、对象

1. 对象的产生有三种方式：（1）工厂方法；（2）构造器new；（3）依赖注入。
2. 引用类型声明的变量，通常称为引用。
3. new出来的对象存储在堆中。
4. 创建对象时，给成员变量分配空间，并赋默认值。
5. 通过引用对堆中的数据进行访问。
6. 成员变量存储在堆中，局部变量存储在栈中。
7. 基本类型之间，“=”是赋值；引用类型之间，“=”意味着指向同一个对象。
8. 当引用类型为null时，不能做任何“.”的操作，不然运行时会提示“NullPointerException”。

 

三、方法

1. 一个类中不可以有签名完全相同的方法。
2. 在一个类中，多个方法的方法名相同，参数列表不同，称为方法的重载。（跟返回值无关）
3. 由编译器根据方法的签名来调用不同的方法。

 

四、构造方法

1. 与类同名，没有返回值，也没有返回类型。
2. 在创建对象时，编译器会自动调用。
3. 构造方法的作用是，初始化成员变量。
4. 若自己不写构造方法，编译器给无参构造，若自己有写，编译器则不再提供。
5. 构造方法（构造器）初始化对象，一般是初始化对象的数据（有时也会有算法）。

 

五、this关键字

1. this用于指代当前对象，谁调用指的就是谁。
2. 当成员变量和局部变量重名时，需要用this关键字来指向成员变量。
3. this([参数]); 用于调用本类的构造方法，如：this();
4. this在运行期间，引用调用方法的对象。

 

六、堆内存

1. 堆中用于存储程序中所创建的对象，包含成员变量。
2. 成员变量生命周期：创建对象时存在，对象被回收时消失。
3. 当一个对象没有被引用时，属于被回收的范围，由垃圾回收器不定时进行回收。
4. 垃圾回收过程时透明的（看不到的），若想快些，用String.gc(); 建议快些回收。
5. 内存泄漏是指不再使用的对象，没有被及时回收。建议：不再被使用的对象，及时将其引用设置为null。

 

七、栈

1. 栈中用于存储所有的局部变量，基本类型直接存储的是值，引用类型存储的是地址。
2. 方法调用时，在栈中开辟一个栈帧，栈帧中存储该方法的参数以及局部变量，当方法调用结束，栈帧被清除，局部变量随之消失。

 

八、方法区

1. 方法区用用于存储类的相关信息，以及类中方法的定义，每个类只被装载一份。

 

九、继承

1. 父类中放子类所共有的东西，子类中放子类所特有的东西。
2. 当继承发生后，子类具有父类的成员以及本类中的成员。
3. java只支持单一继承。
4. 继承具有传递性。

 

十、继承中的构造方法

1. java规定，在子类构造之前，必须先构造父类。
2. 在子类构造方法中，编译器默认假如super(); 用于调用父类无参的构造。
3. super(); 用于调用父类构造方法，必须位于子类构造方法中的第一句。

 

十一、向上造型

1. 父类的引用，可以指向子类的对象，叫做向上造型。
2. 访问类中的成员，是根据引用的类型，而不是对象的类型。

 

十二、重写

1. 方法重写。当子类方法和父类方法的方法签名相同时，子类重写了父类的方法。
2. 当重写发生时，只要和子类相关，调用的就是子类重写后的方法。
3. super方法可以访问父类的方法。（注意static环境下不能使用super）
4. 重写是子类重写了父类的行为，运行期间，根据对象的实际类型，调用相应的方法。

 

十三、包

1. 包package的作用：避免命名冲突。
2. 建议每个类都放在对应的包中，包名所有字母小写。
3. 当声明包和类后，类的全称为：包名.类名
4. 为了避免繁琐，建议通过import来声明类。

 

十四、访问控制修饰符

1. public 公有的，所有类都可以访问。
2. private 私有的，只能本类访问。
3. protected 受保护的，只能子类或同包可以访问。
4. 没有定义修饰符，默认只能同包类可以访问。
5. 访问修饰符，只能用来修饰成员变量和方法，不能用来修饰局部变量。

 

十五、static关键字

1. static修饰成员变量，属于类，存在方法区中，只有一份，通过类名来访问。
2. static修饰方法，通常用作工具方法以及工厂方法。静态方法通过类名来访问。
3. static方法中，不能使用this关键字。静态方法是和对象无关的方法。
4. static块，属于类的代码块，只执行一次，常用于加载静态资源。
5. static方法中，只能直接访问static成员，访问非static成员，需要先new出对象。
6. 静态变量是公共的，非静态变量（也叫实例变量），是属于某个对象的。

 

十六、final关键字

1. final修饰变量，不可被改变。
2. final修饰方法，不可被重写。（防止子类在定义新方法时，造成“不经意”重写）
3. final修饰类，不可被继承。（可以保护类不被继承修改，控制滥用继承对系统造成的危害）

 

十七、static final 常量

1. static final 修饰的成员变量称为常量，必须声明同时初始化。
2. static final 常量会在编译期被替换。

 

十八、抽象方法和抽象类

1. 由abstract修饰的方法为抽象方法，抽象方法只有方法的定义，没有方法体实现，用一个分号结尾。
2. 一个类中，如果包含抽象方法，该类应该用abstract关键字声明为抽象类。
3. 如果一个类继承了抽象类，必须重写其抽象方法（除非该类也声明为抽象类）。重写所有的抽象方法，子类就是一个普通的类，不重写抽象方法，子类也必须是抽象类。
4. 抽象类不可以实例化。
5. 即使一个类中，没有抽象方法，也可以将其定义为抽象类。（意义在于这个类不想被实例化）
6. abstract和final不可以同时用于修饰一个类，因为final关键字使得类不可以继承，而abstract修饰的类如果不可以继承将没有任何意义。
7. 抽象类的定义：（1）为子类提供了公共的类型。（2）封装子类中重复的内容（父类特性）。（3）可定义抽象方法，由子类用不同的方法体重写。

 

十九、接口

1. 接口定义了一个标准的规范。
2. 接口可以看作特殊的抽象类，其中只能包括抽象方法和常量。
3. 实现类（子类）通过implements来实现接口，实现接口必须实现接口中所有的抽象方法。
4. java规定，一个类可以实现多个接口，用逗号分隔，当又想继承又想实现接口时，先继承父类再实现接口。
5. 接口是一种数据类型，可以向上造型：接口名 引用 = new 实现类
6. 接口之间可以相互继承，使用extends关键字。

 

二十、多态

1. 向上造型。（1）一个类的对象可以向上造型的类型有：a.父类的类型，b.其实现的接口类型。（2）java编译器根据类检查调用方法是否匹配。
2. 强制转型。（1）可以将父类和接口看作大类型，子类看作为小类型。（2）小到大，自动向上造型；大到小，需强制类型转换。（3）强转时，看对象。（4）强转有两种情况能成功：a.对象就是那个类型；b.对象实现了那个接口。（5）强转之前，最好通过 instanceof判断，语法：if (引用 instanceof 数据类型){...}
3. 多态的意义：（1）一个类型的引用在指向不同的对象时会有不同的实现。（2）同样一个对象，向上造型成不同类型时，会有不同的功能。

 

二十一、内部类

1. 声明在类内部的类，就是内部类。使用内部类的目的，是为了封装类的定义，使得它只在类的内部有效。
2. 在内部类中，可以使用Out.this来访问外部类的属性和方法。（不写的话默认有）
3. 成员内部类，必须使用外部类实例来创建对象。
4. 成员内部类对象可以访问外部类的属性和方法。
5. 在内部类中，Outer.this与this：（1）可以省略Outer.this访问外部类的对象的属性和方法。（2）可以省略this.内部类对象的属性和方法。（3）如果不能区分外部属性和当前属性的时候，不能省略。

 

二十二、匿名内部类

1. 封装类的定义在方法中。
2. 匿名内部类的语法“简洁”方便。
3. 语法过于简洁，不容易分辨。
4. 是在声明类时，同时创建了一个对象的语法现象。
5. 匿名内部类，一定从父类继承（实现），一定有父类型（类，抽象类，接口）。

 

二十三、类的可见范围与选用

1. 公有类：public class Foo（任何地方可以见）
2. 默认类（同包类）：class Foo（当前包中可见，用的不多）
3. 成员内部类：在一个类内部声明（默认private）
4. 匿名内部类：在方法中定义（最彻底的封装）