java常用關鍵字總結

super

1. 調用父類的非靜態屬性和方法
2. 調用父類的構造方法（必須寫在子類構造方法的第一行）

3. 在子類構造方法中一定要調用父類構造方法，可以通過super指定調用父類的哪個構造方法，如果沒有指定，在實例化子類時會自動調用父類的無參構造方法。

   class Test02 {
   Test02(){
       System.out.println("父類的無參構造方法");
   }
   }
   public class Test01 extends Test02 {
   Test01(int v){//自動調用父類的無參構造方法
       System.out.println("子類的有參構造方法");
   }
   Test01(){
       System.out.println("子類的無參構造方法");
   }
   public static void main(String[] args) {
       new Test01(5);
       new Test01();
   }
   }

   運行結果：
   

4. 如果父類沒有無參構造方法,子類的構造方法必須手動通過super調用父類有參構造方法，否則會報編譯錯誤

class Test02 {
    Test02(int v){
        System.out.println("父類的有參構造方法");
    }
}
public class Test01 extends Test02 {
    Test01(int v){
        super(v);
        System.out.println("子類的有參構造方法");
    }
    Test01(){
        super(7);//注掉該行Test01()處會飄紅
        System.out.println("子類的無參構造方法");
    }
    public static void main(String[] args) {
        new Test01(5);
        new Test01();
    }
}

this

1. 訪問本類的成員變量，解決成員變量與局部變量名稱沖突問題
2. 調用成員方法
3. 調用構造方法（只能在構造方法中調用，必須在第一行，不能互相調用）
   ps:根據形參列表判斷調用的是哪個構造方法

public class Test01 {

    private int id;

    Test01(){
        System.out.println("無參構造方法");
        this.method();
    }

    Test01(int a,int b){
        this(a);
        System.out.println("有參構造方法2:"+a+","+b);
    }

    Test01(int id){
        this();
        this.id = id;
        System.out.println("有參構造方法1:"+id);
    }

    public void method(){
        System.out.println("方法1");
    }

    public static void main(String[] args) {
        new Test01(10,20);
    }
}

運行結果：

final

1. 代碼級別：頂級，成員級別，方法級別
2. final 修飾的類==不能被繼承==
3. 修飾的方法==不能被子類重寫==
4. 修飾的變量是常量，只能賦值一次
5. 修飾的變量是成員變量時，虛擬機不會對其初始化

class Test02{
    public final void  method(){//final修飾，表明該方法為最終方法，不可以被覆蓋重寫
        System.out.println("final修飾的方法");
    }
}

public class Test01 extends Test02 {

    final int ID = 10;
    int num = 9;

//    public void method(){//會報錯:'method()'不能覆蓋'review.Test02' 中的 'method()';重寫方法是 final
//
//    }

    public static void main(String[] args) {
//         new Test01().id = 100;//報錯:無法為 final 變量 'id' 賦值
        System.out.println(new Test01().num);//9
    }
}

abstract

1. 代碼級別：頂級，成員級別
2. 包含抽象方法的類必須聲明為抽象類
3. 抽象類不可以被直接實例化，只能通過子類的實例化
4. 抽象方法必須被子類覆寫，因此==限定符不可以是private==
5. ==抽象方法不可以被static修飾==，如果用static修飾了，那么我們可以直接通過類名調用，而抽象方法壓根就沒有主體，沒有任何業務邏輯，這樣就毫無意義了
6. ==抽象類不能用final修飾==

abstract class Test02{

    public abstract void method();

    public void method2(){
        this.method();//此處的this代表的是繼承該類的類，而不是該類本身
        System.out.println("抽象類內部可以有普通方法");
    }
}

public class Test01 extends Test02 {

    @Override
    public void method() {
        System.out.println("實現抽象類的抽象方法");
    }
    public static void main(String[] args) {
       Test02 test02 = new Test01();
       test02.method();
       System.out.println("===========");
       test02.method2();
    }

}

運行結果：

static

1. 修飾成員變量，成員方法，內部類，代碼塊
2. 代碼級別:成員級別
3. 與對象解綁：非靜態的屬性和方法屬于所在類的對象，靜態的屬性和方法與對象解綁，屬于所在類！！
4. 訪問方式：
   類名.靜態屬性/方法 （推薦）
   對象名.靜態屬性/方法
5. 靜態方法只能訪問用static修飾的屬性和方法（沒有被static修飾的屬性和方法需要創建對象再訪問）。非靜態方法可以訪問靜態方法和屬性
6. 靜態方法中不能出現 this 關鍵字！！！
7. static 修飾的代碼塊和成員變量在類加載時執行！執行順序為書寫順序
8. static 只能修飾內部類！！！
   原因：static實現與對象解綁，外部類都沒有所屬對象，何來解綁一說！

class Test02 {
    Test02(int v){
        System.out.println("父類的有參構造方法");
    }
}
public class Test01 extends Test02 {

    static class Inner{
        Inner(int v){
            System.out.println("靜態內部類的構造方法");
        }
    }

    class Inner2{
        Inner2(int c){
            System.out.println("普通內部類的構造方法");
        }
    }

    static int id;

    Test01(){
        super(7);
        System.out.println("子類的無參構造方法");
    }

    static void mathod(){
        System.out.println("子類的靜態方法");

    }

    public static void main(String[] args) {
        int a = Test01.id;
        Test01.mathod();
        System.out.println("===========華麗的分割線===========");
        Test01 test = new Test01();
        int b = test.id;//合法但不推薦
        test.mathod();//合法但不推薦
        System.out.println("===========華麗的分割線===========");
        Test01.Inner2 inner2 = new Test01().new Inner2(1);//普通內部類的調用
        Test01.Inner inner = new Test01.Inner(4);//靜態內部類的調用

    }
}

運行結果：

補充：

class Test1004{
    public static Test1004 a = new Test1004();
    public static Test1004 b = new Test1004();
    {
        System.out.println("構造代碼塊");
    }
    static{
        System.out.println("靜態代碼塊");
    }
}

public class StaticDemo {
    public static void main(String[] args) {
       Test1004 t = new Test1004();
    }
}

運行結果：

訪問限定符

• private (類訪問級別)：修飾類的成員，則該成員只能被該類的其他成員修飾，其他類無法直接訪問
• default(包訪問級別): 如果一個類或者成員沒有聲明訪問限定符，則默認為該訪問限定符。被該訪問限定符修飾的成員或類只能被本包下的其他類訪問
• protested (子類訪問級別)：被該修飾符修飾的成員可以被同一包下的其他類訪問，也能被不同包下該類的子類訪問
• public（公共訪問級別）：被public修飾的類或者成員，可以被所有的類訪問