Java三大特性：封裝、繼承、多態

每個特性圍繞含義、目的、知識點記錄：

封裝

1、含義：

將對象的狀態信息隱藏在內部，不允許外部程序直接訪問，通過該對象的類所提供的方法進行訪問。

2、目的：

• 1、限制不合理的訪問
• 2、保證對象信息的完成性，便於修改，提高可維護性
• 設計類的原則是，高內聚（功能儘量在內部獨立完成），低耦合（暴露儘量少的方法供外部使用）

3、知識點：

訪問權限表：

	private	default	protected	pubulic
同一個類中	$\surd$	$\surd$	$\surd$	$\surd$
同一個包中		$\surd$	$\surd$	$\surd$
子類中			$\surd$	$\surd$
全局範圍內				$\surd$

繼承

1、含義：

繼承是子類可以使用父類的成員變量和方法，從上表可以看出，繼承的是protected和public的成員變量和方法。

2、目的：

提高代碼的複用性，提高開發效率。

3、知識點：

• 1、Java用extends關鍵字繼承，只能繼承一個類。
• 2、子類中與父類同名方法，會發生重寫，重寫要遵循“兩同兩小一大”的原則。
  • 兩同：函數名相同、形參列表相同
  • 兩小：返回值類型、拋出異常類型 更小或相同
  • 一大：訪問權限比父類方法更大或相同
• 3、重寫與重載的區別：重寫是子類覆蓋父類的方法，而重載是同一個類同，方法名相同，而形參列表不同，根據輸入的參數，執行對應的方法。
• 4、要實現多繼承，在Java中要用到接口
  • 接口繼承用extends，支持多繼承
  • 類實現接口用implements，可以實現多個接口
  • 接口中，只有抽象方法、類方法、默認方法，定義的成員變量是常量。默認方法可以由子類的實例調用，它不是類方法，默認方法的作用是：如果只有抽象方法，那麼修改一個方法所有的子類都要修改，有了默認方法之後，可以只修改默認方法，所有的子類就同時修改了。
• 5、this和super
  • this總是指向調用該方法的對象，主要有兩個用途，一是不用生成新的對象，可以在類的一個方法中調用另一個方法。二是當局部變量與類的成員變量同名時，可以通過this調用類的成員變量。
  • super：當子類重寫了父類的方法時，子類的方法可以通過super來調用父類中被重寫的方法。調用變量和方法是super.xx，而調用父類的構造器是super(形參)。

多態

含義：

多態指的是根據不同的語義會產生不同的結果。Java中有兩種多態機制，編譯時的多態和運行時的多態。其中編譯時的多態是通過重載實現的，根據輸入的形參執行對應的方法。而運行時的多態是通過重寫實現的，編譯時的類型和執行時的類型不同產生了多態。

目的：

多態可以使程序有良好的擴展，並可以對所有類的對象進行通用處理，讓程序的編寫更加靈活。

知識點

編譯時的多態比較簡單，以下的知識點都是運行時多態的知識點：

• 1 運行時的多態的三個條件：

  • 重寫
  • 繼承
  • 父類的引用指向子類的對象

• 2 多態的執行順序：

  • 1、this.f(o) 現在子對象中尋找f方法
  • 2、super.f(o) 再在父類中尋找f方法
  • 3、this.f(super(o)) 在子對象中，尋找輸入的對象o向上轉型爲父類對象super(o)的方法
  • 4、super.f(super(o))，找父類中，向上轉型後的方法。
  • 其中1、3的執行是有條件的，必須是子類重寫了父類的方法，也就是必須存在super.f(o)才能執行this.f(o)，不然會往下一級找。
  • 總體的執行順序就是，現在子類中找，再在父類中找，然後向上轉型，再重複子類->父類的查找順序。

• 通過一個程序例子說明多態的執行順序：

class A{
    protected int pA = 5;
    public String show(A obj){
        return ("A and A");
    }
    public String show(D obj){
        return ("A and D");
    }
    public String show(C obj){
        return ("A and C");
    }
    public String show(E obj){
        return ("A and E");
    }

}

class B extends A{
    public String show(B obj){
        return ("B and B");
    }
    public String show(A obj){
        return ("B and A");
    }
}

class C extends B{
}

class D extends B{
}

class E{
}

class F extends E{
}

public static void main(String[] args) {
        A ab = new B();
        B bb = new B();
        C cc = new C();
        F ff = new F();

        // 按照執行順序是 this.show(o), super.show(o),
        // this.show(super(o)), super.show(super(o))
        // 但是有條件，子類的方法必須在父類中出現

        // 此時的輸出是 B and A
        // 這是 A的引用（命名），B的實例，滿足多態的條件
        // 按照順序，先找this.show(o) 即 B(B) 但是（B）在父類A(B)中未出現
        // 所以找super.show(o) 即 A(B)，也沒有所以找 this.show(super(o)) 即B（A）
        System.out.println(ab.show(bb));
        // 輸出 B and A

        // this.show(o)找不到，找super.show(o) 所以是A(C)
        System.out.println(ab.show(cc));
        // 輸出 A and C

        // 輸出 A and E，最後到super.show(super(o)) 也就是 A(E)
        System.out.println(ab.show(ff));
    }