五、java基础-关键字this_static_super_abstract_final，finalize()方法finally语句块

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语句块，所以这三者没有任何联系，不能把这三者混为一谈。