一：对象模块。
一.初始化
1.对this.super,构造函数，构造代码块，静态代码块总结。
this：代表当前对象，也就是所在函数所属对象的引用。
this对象后面加.调用的是对象的成员变量和方法。（this.say()）;
this对象后面加()，调用的是本类中对应参数的构造函数。
super：代表父类，也就是当前类的父类。
使用方式与this类似。
构造函数：用于当对对象初始化时调用的特殊函数，只在执行一次。
在构造函数中使用this或者super，必须定义在构造函数的第一行。如果没有用到，那么构造函数的第一句会默认的加上super（）;
构造代码块：是给所有的对象进行初始化，也就是，所有的对象都会调用的一个代码块，只要对象一建，就会调用这个代码块，用于给不同对象的共性初始化，优先于构造函数执行。
格式：{
代码。。。。。。
}
静态代码块：一个用static关键字标示的一个代码块区域，定义在类中。可以完成类的初始化，静态代码块会随着类的加载而执行一次（new多个对象也是只执行一次）。如果和主函数在同一个类中，优先于主函数执行。
格式：static{
代码。。。。。
}
三种初始化的执行顺序: 静态代码块--->构造代码块------>构造函数。
二.继承(extends)：
1.重写和重载
重写：覆盖父类已有的方法，子父类方法必须一模一样。(包括返回值，子类复写父类方法时访问权限必须比父类大或者同级。方法要么都静态，要么都不静态)。
重载：只在本类中的多个方法，只看同名函数的参数列表。
子类初始化时，先初始化父类的方法和变量，在初始化自己的。
三.接口(implements)
1.实现
接口可以被多实现，类继承只能单继承。
接口与接口之间存在着继承关系，接口可以多继承接口。
四.多态
体现：父类或者接口的引用指向自己的子类对象。（注意：在使用多态时，要访问子类的方法，要求父类中必须对该方法进行了声明或者定义）。
多态在子父类中的成员上的体现的特点：
成员变量：
编译时期：参考的引用类型变量所属的类中是否有调用的成员。（编译时期不产生对象，只检查语法错误）。
运行时期：也是参考引用类型变量所属的类中是否有调用的成员。
简单总结：成员变量——编译运行都看 = 左边。
非静态成员函数：
编译时期：参考引用类型变量所属的类中是否有调用的方法。
运行时期：参考的是对象所属的类中是否有调用的方法。
原因：因为在子父类的非晶态成员函数中有一个特性：重写（覆盖）。
简单总结：成员函数——编译看 = 左边， 运行看 = 右边。
静态函数：
编译时期：参考引用类型变量所属的类中是否有调用的方法。
运行时期：参考的是引用类型所属的类中是否有调用的方法。
原因：因为是静态方法，所以是不属于对象的，而是属于该方法所在的类。
简单总结：成员函数——编译运行看 = 左边，
五：内部类。
特点：内部类可以直接访问外部类中的成员，而外部类想要访问内部类，必须要建立内部类的对象。
-------------------------------------------------------------------------------------------------------------------------------
class Outer{
int num = 4;
class Inner {
void show(){
System.out.println("inner show run" + num);
}
}
public void method(){
Inner in = new Inner();//创建内部类的对象
in.show();//调用内部类的方法
}
-------------------------------------------------------------------------------------------------------------------------------
当内部类定义在外部类的成员变量位置。可以使用一些成员修饰符进行修饰默认,private,static.
1.默认修饰符。
直接访问内部类格式：外部类名.内部类名 变量名 = new 外部类对象.内部类对象；
Outer.Inner in = new Quter.new Inner();
上面这种方式比较少见，因为内部类本来就是为了封装，想要获取内部类对象通常都是通过外部类的方法来获取，这样可以对内部类对象进行控制。
2.private修饰符。
通常内部类被封装，都会被私有化。
3.静态修饰符。
如果内部类被静态修饰，相当于外部类，会出现访问局限性，只能访问外部类中的静态成员。
注意：如果内部类中定义了静态成员，那么该内部类必须是静态的。
当外部类的静态方法访问内部类时，内部类也必须是静态的。
外部其他类中，直接访问static内部类的非静态成员：New Outer.Inner().show();
外部其他类中，直接访问static内部类的静态成员：Outer.Inner.show();
一般内部类经过编译后文件名为：“外部类名$内部类名.class”;
当内部类被定义在局部位置上时。
1.不可以被成员修饰符修饰（例如：static，static是修饰成员的）
2.可以访问外部类中成员，因为还持有外部类中的引用，（外部内.this）,但不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量。
匿名内部类：
意义：没有名字的内部类，是内部类的简化形式，一般内部类只用一次的话就可以用这种形式。匿名内部类其实就是一个匿名子类对象，想要定义匿名内部类：需要前提，内部类必须实现一个接口或者继承一个类。
匿名内部类的格式：new 父类名&接口名（）{定义子类成员或者覆盖父类方法}.方法
case：
new Object(){
void show(){
System.out.prinlt("show run");
}
} .show();
六：异常。
1.使用throws来在方法上标识（声明），方法可能会出现异常，当调用者检查到有标识时有必须要进行处理，要么接着抛，要么try。否则会出现编译失败
声明格式：throws 异常类，异常类。。。。。并不是所有的异常都需要声明，RuntimeException（运行时异常）类及其子类可以不用声明。
2.捕获异常try{}catch(){}块来捕捉时，要注意有多个catch时，如果有父类的Exception语句块，一定要放在下面.
3.throw用于抛出异常对象。
异常，在子父类进行覆盖时，有以下特点：
1.当子类覆盖父类的方法时，如果父类的方法抛出了异常，那么子类的方法要么不抛出异常，要么就抛出父类异常或者该异常的子类，不能抛出其他异常。如果父类没有抛出异常，那么子类只能try不能throws.
2.如果父类抛出了多个异常，那么子类在覆盖时只能抛出父类异常的子集。
3.如果这个异常子类无法处理，已经影响了子类方法的具体运算，这时可以在子类方法中，通过throw抛出RuntimeException异常或者其子类，这样，子类方法就不需要throws进行声明。
注意：throw下面不能写语句，因为执行不到（会出现编译错误，和return,break后面不能写代码类似），但是注意如果是分支结构，也就是说if语句内写是可以的。
七：多线程。
1.相关概念。
进程：正在进行中的程序，就是一个应用程序运行时的内存分配空间
线程：进程中一个程序的执行控制单元，一条执行路径。
进程负责的是应用程序的空间的标示，线程负责的是应用程序的执行顺序。
cpu随机性原理：因为cpu的快速切换造成，那个线程获取到了CPU的执行权，那个线程就执行。
2.线程的几种状态：
被创建：start()。
运行：具备执行资格，同时具备执行权。
冻结：sleep（time）,wait()-----notify()唤醒，线程冻结（沉睡），释放了执行权，同时释放了执行资格。
临时阻塞状态：线程具备cpu的执行资格，没有cpu的执行权。
消亡：stop();
3.两种线程的创建方式
第一种方式：继承Thread,由子类复写run方法。
步骤：1.定义类继承Thread类。
2.目的是复写run方法，将要让线程运行的代码都存储到run方法中。
3.通过创建Thread类的子类对象，创建线程对象。
4.调用线程的start方法，开启线程，并执行run方法。
第二种方式：实现一个Runable接口。
步骤：1.定义类实现Runnable接口。
2.覆盖接口中的run方法。（
