0.方法签名：方法名+参数列表
1.方法的重载（Overload）：
（1）、方法名相同，参数列表不同，
（2）、在编译器在编译时根据方法的签名自动绑定调用方法
2.构造方法：
（1）、给成员变量赋初值
（2）、没有返回值类型
（3）、在创建对象时自动调用
（4）、
3.this：
只能用在方法里，放在中访问成员变量之前默认有，当成员变量与局部变量重名时，this.不能省略
用法：this.成员变量名----------访问成员变量
this.方法名（）-----------调用方法（一般不用）
this（）调用构造方法
4：null和NullPointerException：
null：空，没有指向任何对象
若操作发生NullPointerException：空指针异常
5：引用类型变量画等号：
（1）、指向同一个对象
（2）、通过一个引用对数据的修改会影响另一个引用对数据的值
基本类型变量画等号：
（1）、赋值
（2）、对一个变量的修改不会影响另一个变量的访问
内存管理：由JVM来管理的
（1）、堆：new出来的对象（包括成员变量）
（2）、栈：局部变量（包括方法参数）
(3) 、方法区：.class字节码文件（包括方法）
回顾：
1、方法的重载：
（1）、发生在一个类中，参数列表不同，方法体不同
（2）、编译器在编译时根据方法的签名自动绑定调用的方法
2、构造方法：
（1）、给成员变量赋初值、与类同名，没有返回值类型
（2）、创建对象时被自动调用
（3）、若自己不写，则默认无参构造自己写了则不再默认无参构造
3、this：
哪个对象调用方法指的就是那个对象
this.成员变量-------------------访问成员变量
this.方法名----------------------调用方法
this（）-------------------------调用构造方法
4、null：空，没有指向任何对象
引用的值为null
1、引用类型数组：
（1）、Student [] stus = new Student[10];
stus[0] = new Student();
stus[0].age = 25;
Student [] stus = new Student []{
new Student(),
new Student(),
new Student()
}
基本类型变量---------------------装具体的数
引用类型变量---------------------装地址
（2）
//声明int[]的数组，包含3个元素
//每个元素都是int[]型
int [][] arr = new [3][];
arr[0] = new int[2];
arr[1] = new int[3];
//给arr中第二个元素中的第一个元素赋值为100
arr[1][0] = 100;
arr-------------------------------int[][]
arr[0]----------------------------int []
arr[0][0]-------------------------int
（3） //数组的数组
int [][] arr = new int[3][];
arr[0] = new int [2];
arr[1] = new int [3];
arr[2] = new int [2];
arr[1][0] = 100; //给arr第二个元素中第一个元素赋值100
（4）int [][] arr = new int[3][4];
for(int i = 0;i<arr.length;i++){
for(int j = 0;j<arr[i].length;j++){
arr[i][j] = (int)(Math.random*100));
}
}
2、继承：
（1）、作用：代码复用
（2）、通过extends来实现继承
（3）、超类/父类：所有派生类所共有的属性和行为
派生类/子类：派生类所特有的属性和行为
（4）、派生类继承超类后，派生类具有：派生类的+超类的
（5）、一个超类可以有多个派生类，一个派生类只能继承一个超类
（6）、继承具有传递性
（7）、java规定：构造派生类之前必须先构造超类
派生类中若没有调用超类的构造方法，则默认super（）调用超类的无参构造方法
派生类若调用了超类的构造方法，则不再默认
super()调用构造方法，必须放在派生类构造方法的第一句话。
3：super：指代当前对象的超类对象
（1）、super.成员变量名---------------------访问超类的成员变量
（2）、super.方法名（）---------------------调用类的方法
（3）、super（）----------------------------调用超类的构造方法
1、向上造型：
（1）、超类型的引用指向派生类的对象
（2）、能点出来什么要看引用类型
2、方法重写：
（1）、发生在父子类中，方法名相同，参数列表相同，方法体不同。
（2）、重写方法被调用时，看对象的类型
（3）、重写遵循“两同两小一大”规则：
方法名称相同，参数列表相同；派生类方法的返回值类型小于或等于超类返回值类型，派生类方法抛出的异常小于或等于超类方法 ；派生类的访问权限大于或等于超类方法的访问权限。
超类返回值是void和基本类型必须相等，引用类型可以小于等于
3、重写与重载的区别------------面试题
（1）、重写（Override）：
发生在父子类中，方法名相同，参数列表相同
遵循“运行期”绑定，看对象的类型来调用方法
（2）、重载
发生在一个类中，方法名相同，参数列表不同
遵循“编译期”绑定，看参数/引用的类型来绑定方法
（重载看参数/引用的类型，重写看对象的类型）
编译期：java源文件，经过编译，生成.class字节码文件
运行期：JVM加载.class并运行.class
1、package：避免类的命名冲突
包名可以有层次结构，同包中的类名不可以重名
域名反写 . 项目名称 . 模块名称 . 类名
类的全称：包名.类名
建议：包名的字母全部小写
import：（1）、同包中的类可以直接访问
（2）、不同包必须用import
2、访问控制修饰符：（数据私有化，行为公开化）
（1）、public：公开的，任何类
（2）、protected：本类，同包类，派生类
（3）、默认的：本类，同包类
（4）、private：私有的，本类使用
说明：类的访问修饰，只能是public或默认的
类中的成员
3、final：最终的、不可改变的
（1）、修饰变量：变量不可改变
（2）、修饰方法：方法不能被重写
（3）、修饰类：类不能被继承
4、static：静态的
（1）、静态变量：
（1.1）、由static修饰
（1.2）、属于类，存储在方法区中，只有一份
（1.3）、常常通过类名点来访问
（1.4）、何时使用：所有对象共享的数据
（2）、静态方法：
（2.1）、由static修饰
（2.2）、属于类，存储在方法区，只有一份
（2.3）、常常有类名来调用
（2.4）、静态方法中不能直接访问实例成员（没有隐式this的传递），但可以访问静态成员
（2.5）、何时用：方法的操作仅与参数相关而与对象无关
（3）、静态块：
（3.1）、属于类，在类被加载期间自动执行，因类只被加载一次，所有静态块只执行一次
（3.2）、何时用：加载/初始化静态资源
1、static final常量：
（1）、必须声明同时初始化
（2）、通过类名点来访问
（3）、建议：常量名所有字母都大写，多个单词用_分隔
（4）、编译器在编译时将常量直接替换为具体的值，效率高
（5）、何时用：数据永远不变，并且经常使用
2、抽象方法：
（1）、由abstract修饰
（2）、只有方法的定义，没有方法体
3、抽象类：
（1）、由abstract修饰
（2）、包含抽象方法的类必须是抽象类（或接口）
（3）、抽象类不能实例化
（4）、抽象类是需要被继承的，派生类：
（4.1）、重写所有抽象方法---------------------常用
（4.2）、也声明为抽象类-----------------------不常用
（5）、抽象类的意义：
（5.1）、可以封装共有的属性和行为--------代码复用
（5.2）、为所有派生类提供统一的类型------向上造型
（5.3）、可以包含抽象方法，为所有派生类提供统一入口，派生类的具体行为不一样，但入口是一致的
1、成员内部类：
（1）、类中套类，外面的称为Outer外部类，里面的称Inter内部类
（2）、内部类通常只服务外部类，对外不具备可见性
（3）、内部类对象通常只在外部类创建
（4）、内部类可以直接访问外部类成员（包括私有的）
内部类有个隐式的
2、匿名内部类：
（1）、若想创建一个类的对象，并且对象只被创建一次，此时该类不必命名，称为匿名内部类
（2）、匿名内部类中若想访问外面的变量，该变量是fianl（JDK1.7以前）
（3）、
MouseAdapter l = new MouseAdapter(){
public void mouseMoved(MouseEvent e){}
};
this.addMouseListener(l); //处理鼠标操作事件
this.addMouseMotionListener(l); //处理鼠标滑动事件
1、接口：
（1）、由interface定义
（2）、数据类型只能是常量和抽象方法
（3）、是一种数据类型
（4）、接口不能被实例化
（5）、接口是需要被实现的，必须重写接口中的所有抽象方法
（6）、一个类可以实现多个接口，用逗号
（7）、接口可以继承接口
2、设计规则：
（1）、将派生类所有的属性和行为，抽到超类中----------抽共性
（2）、所有派生类的行为都一样，设计普通方法
所有派生类的行为不一样，设计抽象方法
（3）、将部分派生类所有的行为，抽到接口中
1、多态：
（1）、意义：
（1.1）、行为多态：同一类型的引用指向不同的对象时，有不同的实现
（1.2）、对象多态：同一对象被造型为不同类型时，有不同功能
（2）、向上造型:
（2.1）、超类型的引用指向派生类的对象
（2.2）、能造型 成为的数据类型有：超类+所有实现的接口
（2.3）、能点出什么，看引用的类型
（3）、强制类型转换，成功的条件只有如下两种：
（3.1）、引用所指向的对象，就是该类型
（3.2）、引用所指向的对象，实现了该接口
（4）、强转若不符合如上条件，则发生ClassCastException类型转换异常
建议：在强转之前用instanceof来判断
1、内存管理：由JVM管理的
（1）、堆：
（1.1）、存储new出来的对象（包括实例变量）
（1.2）、垃圾：没有任何引用所指向的对象
垃圾回收（GC）不定时到内存中清理垃圾
回收过程是透明的（看不到的）
不一定一发现垃圾就回收，通过调用System.gc()可以建议调度GC来回收
（1.3）、实例变量的生命周期：创建对象时存储在堆中，对象被回收时一并被回收
（1.4）、内存泄漏：不再使用的对象还没有被即时回收
建议：对象不再使用时，及时将对象设置为null
（2）、栈：
（2.1）、存储正在调用方法中的局部变量（包括方法的参数）
（2.2）、调用方法时会在栈中为该方法分配一块对应的栈帧，栈 帧中存储方法中的局部变量（包括参数）
方法结束时，栈帧被清除，局部变量一并被清除
（2.3）、
（3）、方法区：
（3.1）、存储.class字节码文件
（3.2）、方法只有一份，用this.来区分具体调用对象
实例变量：
（1）、类中，方法外
（2）、创建对象时存储在堆中，对象被回收时一并被回收
（3）、有默认值
局部变量：
（1）、方法中
（2）、调用方法时存储在栈中
（3）、没有默认值
面向对象三大特点：继承、封装、多态
1、封装：
（1）、类：封装的是对象的属性和行为
（2）、方法：封装特点的业务逻辑功能实现
（3）、访问控制修饰符：封装的是具体的访问权限
2、继承：
（1）、作用：代码复用
（2）、超类：所有派生类所共有的属性和行为
接口：部分派生类所有的共有的行为
派生类：派生类所特有的属性和行为
（3）传递性：单一继承，多接口实现
3。多态：
（1）意义：行为多态：所有抽象方法都是多态的
对象的多态：所有对象都是多态的
（2）、向上造型、强制类型转换，instanceof判断
（3）、多态的表现形式：
（3.1）、重写：根据对象的不同来表现多态
（3.2）、重载：根据参数的不同来表现多态
