1．构造方法：

如果类中不写构造方法，编译器会默认添加构造方法，内部只有一句super();

Class A {

public A(){

super()

}

}

2. this是实例内部的一个特殊引用，保存当前实例的内存地址

方便构造方法之间的相互调用，通常在参数少的构造方法中调用参数多的构造方法

this() 必须是构造方法中的首行代码

public A() {

this(0);

…

}

3. 方法重载 Overload。同名不同参。简化对外接口。

public String getPrice(id);

public string getPrice(name)

4. 访问控制符


本类包子类其他类

public

0000protected000
[default]00

private0


使用原则：尽量使用private

Public是与其他开发者的一个契约，公共的成员会保持稳定不变。

5. 继承

目的：代码重用，只允许继承一个父类

继承：有访问权限的成员

不继承：不可见的成员、构造方法、静态成员

创建子类实例执行顺序

1、先创建父类实例

2、再创建子类实例

3、两个子类实例绑定在一起作为子类实例

构造方法执行顺序

1、先执行父类构造方法

2、再执行子类构造方法

3、默认会执行父类的无参构造方法super()

如果父类不存在无参构造方法，子类中必须手动调用父类有参构造方法。

6. Super：

1、子类中调用父类的构造方法：Super()

2、但必须是构造方法的首行代码

3、重写方法时，可以调用父类中的同一个方法。

4、Super.funcName();

7. 重写Override

用途：从父类继承的方法，不满足子类需要时，在子类中重新编写这个方法。

重写的规则：

1、 方法签名(返回类型、方法名、参数列表)必须一致

2、 访问范围不能变小

3、不能抛出更多的异常

8. 多态：

作用：以一致的类型来处理多种子类型实例

1、向上转型：子类实例转为父类类型

Shape s = new Line();

2、向上转型，子类中特有成员被因擦，只能调用父类中的通用成员。

3、向下转型，必须强制转型

4、被转为父类类型的子类实例，可以还原为原始类型

Line line = (Line) s;

5、运行期类型识别

instanceOf，对子类型和父类型都会返回true。

9. 抽象类：abstract

1、作用：

1).为子类提供通用代码

2).为子类定义通用的API

2、半成品类，不能创建实例

3、包含抽象方法的类，必须是抽象类

4、抽象类不一定有抽象方法（不解）

10. final：

1、可以用来修饰变量、方法、类

2、常量的定义通常同时使用final、static一起使用

3、译期优化或运行期优化

final byte a = 2;

final byte b = 3;

byte c= a + b;

编译期优化为：byte c= 5;

4、final方法：不能被子类重写

5、final类：没有子类，不能被继承

11. Static

1、静态属性

2、属于类，而不属于实例

3、调用时，通常使用类名调用

4、能不用，尽量不用

5、属于非面向对象语法（基本数据类型也是）

6、共享的数据Math.PI

7、工具类方法：Math.sqrt();

8、静态初始化块：

Static {

….

}

第一次使用到其所在类的时候，会自动执行，并且只执行这一次。

12. 接口

1、作用：结构设计工具，用来解耦合

2、极端的抽象类

3、只能定义

1)、抽象方法

2)、常量

3)、内部类，内部接口

4、所有的成员都是公共的

5、可以同时继承多个接口

6、接口之间可继承interface A extends B,C,D

13. 内部类

* 定义在类内部或局部代码块中的类

* 非静态内部类

*) 属于实例，要用外部类实例来创建

*) 不能定义静态成员

class A {

class Inner {

}

}

A a = new A();

A.Inner b = a.new Inner();

A.Inner b = new A().new Inner();

* 静态内部类

class A {

static class Inner {

}

}

A.Inner a = new A.Inner();

* 局部内部类

*) 局部内部类，使用外面的局部变量必须加 final

class A {

void a(final int i) {

final int j=10;

class Inner {

void a() {

i+j

}

}

Inner a = new Inner();

}

}

* 匿名内部类

Super s = new Super(){};

* 为什么使用内部类

*) 基于个人设计理念

*) 两个类型关系紧密

*) 完全隐藏类型