1、关键字this
含义：this 是一个引用类型，代表当前对象，引用类型里面必然保存内存地址，在堆中的每个对象中存储，保存内存地址指向自身。
用法：
1）this可以用在成员方法中，里面保存内存地址，指向当前变量
2）this可以用在构造方法中，其他地方是不能用的；
int empno;
//员工姓名
String ename;
//Constructor
Employee(){
this(12,zhangsan);//this(实参);表示通过一个构造方法去调用另外一个构造方法，且必须出现在构造方法的第一行。
}
Employee(int _empno, String _ename){
empno= _empno;
this.ename=_ename;//this用在构造方法中
}
public void work(){
System.out.println(ename+"在工作");
System.out.println(this.ename+"在工作");//这两种效果是一样的。
//成员方法
public void m1(){
this.m2();//this用在成员方法中
m2();
}
//成员方法
public void m2(){
System.out.println("THSWEOD");
}
3)this 不能用在静态方法中
静态方法的执行根本不需要java对象的存在，直接使用类名.方法名的方式访问。而this代表的是当前对象，所以静态方法中根本没有this，如果使用this.则编译无法通过
2、static关键字
1）static修饰的变量叫做“静态变量”--->类名.变量名
2）static修饰的方法叫做“静态方法”--->类名.方法名 或 引用.方法名 或 方法名；静态方法中不能使用非静态数据：成员变量和成员方法；静态方法中不能使用this
3）static还可以定义静态语句块 static定义的静态语句块在类加载阶段执行，并且只执行一次。并且是自上往下的顺序执行。
开发的过程中：一般工具类的方法都是静态方法
备注：
静态变量意味着所有的java对象都共用这一块东西。静态变量存放在方法区。放在方法区中，表示java中的每一个类型对象都共享一份。所以静态变量属于类级别的。
什么时候变量声明成静态变量？
如果这个属性所有对象都有，并且这个属性的值是相同的，则该属性声明成静态变量。这样让其在方法区中存储一份，可以节省空间。
成员变量：在创建java对象的时候初始化
静态变量：在类加载的时候赋值，并且只赋值一次。
//静态语句块
static {
System.out.println("1");
}
//实例语句块：每一次调用构造方法之前会执行一次，即每次创建对象之前会执行一次。调用n次就会执行n次
{
System.out.println("1");
}
备注：为什么main方法定义成public static void main(String[] args){} ？
为了方便java虚拟机的调用。换句话说java虚拟机在调用main方法的时候，不需要创建对象。直接使用类名.main方法 公开的静态的、方法结束之后不需要有返回值。
//空的引用去访问成员的时候会出现空指针异常
//m2方法不是“成员”而是静态的，所以即使引用是空的，也不会报空指针异常
3、类中可以包含：
类{
//可以通过“类名.”，也可以通过“引用.”,即使使用“引用.”底层也是“类名.”
1）静态变量
2）静态方法-->如果方法中不需要当前对象的一些东西，而是整个类的东西，那么该方法就声明成静态的方法
//必须对象存在才可以访问，采用“引用.”
3）成员变量
4）成员方法-->如果方法中用到了，当前对象的一些方法，则需要将该方法声明为成员方法
//创建对象给成员变量赋值
5）构造方法
//类加载时只执行一次
6）静态语句块
//构造方法没有调用之前执行一次
7）实例语句开
//用在成员变量和构造方法中
8）this
空引用访问成员时会出现空指针异常。（成员包括：成员变量和成员方法）
访问静态不会出现空引用异常。
}
4、super关键字
1）super代表的是当前子类对象中的父类型特征，不是引用类型，存储的不是内存地址，指的不是父类对象;例如子类和父类中都有某个属性，如果要在子类中访问父类中的name属性，需要使用super.name;
2）super可以用在成员方法、构造方法中，不能用在静态方法中；this和super相同，都不能用在静态上下文当中
super在构造方法中的作用是通过子类的构造方法去调动父类的构造方法(但是并没有创建java对象)，从而给当前子类对象中的父类型特征赋值
super在成员方法中是通过当前子类对象去访问父类型特征
注意：构造方法的执行不一定创建对象。因为super()也算构造方法执行了，但是并没有创建对象。
通过子类的构造方法去调用父类的构造方法，一定会执行父类的构造方法，但是这个构造方法的执行并不一定会创建对象。它只是为了当前子类对象的父类型特征赋值。
public class Account {
private int actno;
private double balance;
public Account(){
System.out.println("父类的构造方法执行");
}
public Account(int actno, double balance) {
super();
this.actno = actno;
this.balance = balance;
System.out.println("账户号是："+actno+","+"账户余额是："+balance);
}
}
public class debitAccount extends Account {
private double debit;
public debitAccount() {
super();
/*有super();的效果和没有super();的效果是一样的
* 无参数的构造方法第一行什么都没写，则系统默认调用父类里面的构造方法,若是父类里面的构造方法私有化了，则编译无法通过
* 因此：单例模式的类型没有子类型，无法被继承。因为单例模式最大的特点就是构造方法私有化。而构造方法私有化之后则无法被
* 继承。
* */
}
debitAccount(int actno,double balance,double debit){
super(actno,balance);
this.debit=debit;
System.out.println("信用额度为"+debit);
}
}
public class Test02 {
public static void main(String[] args) {
debitAccount da1=new debitAccount();
debitAccount da2=new debitAccount(12,30,400);
}
}
4、抽象类
1）抽象类：由abstract修饰的类
抽象类无法实例化(即无法创建对象)，但是抽象类也有构造方法，该构造方法是给子类型创建对象；也说明了调用构造方法无法创建对象。抽象类中不一定有抽象方法，但是抽象方法一定出现在抽象类中。
一个非抽象类继承抽象类，必须将抽象类中的抽象方法覆盖，实现，重写；
2）抽象方法：由abstract修饰，并且方法没有方法体{},以;结束
public abstract class Abs_a {
//抽象类中也有构造方法，是给子类创建对象用的
int a;
double b;
Abs_a(){
System.out.println("父抽象类的无参数构造方法执行");
}
//抽象类虽然可以有有参数的构造方法，但是无在子类中对该抽象父类进行实例化
public Abs_a(int a,double b){
System.out.println("父抽象类的有参构造方法执行");
}
public abstract void m1();
}
public class Abs_b extends Abs_a {
public static void main(String[] args){
Abs_b ab1=new Abs_b(); //此时父类的无参数构方法会执行
ab1.m1();
/*Abs_a ab2=new Abs_a(12,30);
* 抽象类虽然可以有有参数的构造方法，但是无在子类中对该抽象父类进行实例化,否则编译无法通过
*/
Abs_b ab2=new Abs_b(10,30);
}
@Override
public void m1() {
// 一个非抽象类继承抽象类，必须将抽象类中的抽象方法覆盖，实现，重写；
System.out.println("实现/重写抽象类Abs_a中的抽象方法");
}
public Abs_b(){
super();//父类的无参数构方法也会执行
}
public Abs_b(int a,double b){
this.a=a;
this.b=b;
System.out.println("a的值为"+a+"b的值为"+b);
}
}
5、final关键字
1) final修饰的类无法被继承
2) final修饰的方法无法别覆盖
3) final修饰的局部变量，一旦赋值，不能在改变
4) final修饰的成员变量必须“显示的”初始化，即必须手动的赋值。final修饰的成员变量在构造方法调用结束之前，只要能附上值就行。例如 final int k=100;或者通过构造方法 A(){ k=100;}进行赋值
5) final修饰的成员变量一般和static联用,用来定义常量 public static final double PI = 3.13;常量是值不可在改变的变量，“类名.常量名”访问
6) final修饰的引用类型，该引用不可以再重新指向其他的java对象，但是final修饰的引用，该引用指向的对象的属性是可以修改的。final Customer c=new Customer("jack",45); c=new Customer("LUCY",20);//Error
备注：抽象类不能被final修饰，抽象方法不能被final修饰。即final不能和abstract共存；
finalize：是object里面的一个方法的名字，压根就不是关键字，垃圾回收器在回收java对象之前，会先自动调用java对象的finalize方法，
finally: 是异常处理机制中的finally语句块，所以这三者没有任何联系，不能把这三者混为一谈。