复习
一、继承：
1、继承出现的目的：复用性的问题
2、父类和子类之间有相关性：子类是一种特殊的父类；子类表示是父类的一个子集
3、语法：
定义相关的语法：class 子类 extends 父类{}
只能单继承，不能多继承
4、方法:
（1）覆写/重写 @Override
方法名称相同 + 形参列表相同 + （返回值相同 | 子类）
（2）重载
5、对象模型：
子类的对象中，可以认为存在一个完全体的父类对象（即父类的所有属性，在子类对象中都存在，但可能没有访问权限）
访问限定：子类能否访问父类的属性和方法
public、protected ：可以
default/private-protected ：如果在一个包下是可以的
private ：不可以
6、语法：super 关键字的作用
（1）明确访问父类的属性或者方法
（2）显式调用父类的构造方法，必须出现在第一行
7、编译期和运行期
（1）编译期：编译器（javac）在运行；把 *.java转化为 *.class
（2）运行期：用JVM（Java虚拟机）运行我们实际写的程序（java）
8、类的加载：发生在运行期，把类的字节码文件加载到内存中（方法区）的过程
9、对象的实例化：发生在运行期，根据类的内存信息，在内存中（堆区）构造对象的过程
10、关于类的加载：
（1）需要的时候才加载
（2）构造该类的对象/调用该类的静态属性or静态方法/反射/子类触发父类
（3）父类的加载一定是发生在子类之前
父类的静态属性初始化过程一定是发生在子类的静态属性初始化之前
静态属性的初始化是发生在类的加载时期的
11、关于对象的实例化：
（1）父类属性的初始化一定是发生在子类属性的初始化之前
（2）初始化顺序：
1）按书写顺序执行，定义时初始化 or 构造代码块
2）统一执行构造方法
12、名字的遮挡
class A{
int a;
}
class B extends A{
int a;
public void method(int a){
a;
}
}变量名 是否有歧义 解释
a 是 1、局部变量/形参a；2、属性中的a（1）本类中的属性a（2）父类的属性a；3、外部类中的a
this.a 是 属性中的a （1）本类中的属性a（2）父类中的属性a
super.a 否 父类的属性a
Outter.this.a 否 外部类的属性a
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
一、接口（语法）
1、出现的目的：体现封装性；分离契约和实现；区分开甲方（提要求）和乙方（干活）
2、接口可以认为就是一份合同（契约）
3、语法定义：
interface 接口名称{
void volumnUp(); //抽象方法
}
//例如:
interface Collection{}
interface DataStructure{}
interface List extends Collection,DataStruture{}(1)接口的定义允许多继承
（2）接口无法去实例化对象
（3）接口中给出的方法列表默认：public 访问限定修饰；无法使用static修饰（有特例）；是一个抽象方法，直接用分号结尾， 不用给出方法体
（4）接口中不能出现属性（也可以出现，不过默认都是被final static 修饰）
（5）语法：类实现接口的语法，写在定义类的时候
interface JavaCourse{
void 上课();
void 辅导();
void 留作业();
}
class 陈老师 implements JavaCourse{
@Override
void 上课(){……}
……
}
class 汤老师 implements JavaCourse{
@Override
void 上课(){.....}
……
}
//接口允许多继承
class A extends Parent implements IA,IB,IC{
}（6）接口允许多继承
二、final 关键字，修饰三个位置
1、修饰变量，不可变变量，只有一次赋值机会；
final int a=10;
a=100； //触发编译错误
final int[] a=new int[10];
A) a=new int[100];//触发编译错误
B)a[0]=100;//正确的
final Person p=new Person();
A)p=null;//触发编译错误
B)p.name="Hello";//正确的2、final 可以修饰类，表示这个类不能被继承：final class A {}
3、final 可以修饰方法，代表这个方法无法被其子类覆写
class A { final void method() {} ……}
三、abstract
1、修饰类，表示这个类无法被实例化
abstract class A{} //抽象类
new A（）； //编译错误
2、修饰方法，该方法称为抽象方法，只有方法签名，没有方法实现
abstract void method ();
List(接口)
抽象方法：pushFront/pushBack/insert
AbstractList（抽象类）实现了List
覆写了 pushFront/pushBack
留了一个抽象方法 insert
ArrayList（类）继承了AbstractList实现了List
覆写了 insert
3、抽象方法一旦被实现了一次，就不再是抽象方法
4、AbstractList中只是线性表，把公共代码提取出来复用，所以无法实现insert 方法，因为顺序表和链表的insert是不同的
三、多态：
例如：狗和猫都是动物，都可以叫，但是种类不同，叫声不同
1、父类型的引用可以指向子类型的对象
例如：List P ; AbstractList q; ArrayList o; LinkedList l;
(1)List p = new ArrayList(); //父类对象的实例化，等号后边的可以是它自己也可以是它的子类
AbstractList q = new ArrayList();
ArrayList o = new ArrayList(); //子类对象的实例化，等号后边的只能是它子集
（2）以返回值类型体现：
List getList(){ return new ArrayList(); }
(3)以参数体现
void list（List list）{……}
list ( new ArrayList();)
list (new LinkedList(); )
2、引用可以调用的方法有哪些，在编译期间，是根据引用的类型来决定，不是根据对象的类型
class A{
int a(){}
}
class B extends A{
int b(){}
}
A aa=new A();
aa.a();
A ab=new B();
ab.a();
ab.b();//编译错误
B bb=new B();
bb.a();
bb.b();
B ba=new A();//编译错误！！！！！！！！！！总结：
多态：
1、父类型的引用可以指向子类型的对象（向上转型）
2、编译期间，可以调用的方法列表，以引用类型为准
3、运行期间，真正执行的普通方法，以实际执行的对象类型为准
4、运行期间，真正执行的静态方法，以应用类型为准
