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

时间:2021-04-29 16:39:11

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