Java 核心概念深度解析：封裝、繼承、多態、構造器鏈與動態綁定機制

面向對象三大支柱

1. 封裝

• 基本單元：類
• 核心目的：隱藏實現細節，暴露公共接口
• 兩大優勢：
  • 模塊化：獨立開發、維護、傳遞
  • 信息隱藏：外部僅通過公共接口交互，內部變更不影響調用者

2. 繼承

• 子類獲取父類屬性與方法，實現代碼復用
• 子類是父類的特化實例，支持向上轉型
• Java 單繼承，但可實現多接口

3. 多態

• 本質：「一個接口，多種實現」
• 兩種形式：
  • 方法重載：同名、參數列表不同（編譯期綁定，靜態綁定）
  • 方法覆蓋：子類重寫父類方法（運行期綁定，動態綁定）

動態綁定核心規則

除 static、final、private 方法外，所有實例方法均為動態綁定。

• final：編譯器可內聯優化，性能微增
• static：屬於類，不屬於實例，無多態行為
• private：不可被子類訪問，本質等同 final

靜態方法無多態演示

class StaticSuper {
    public static String staticGet() { return "Base staticGet()"; }
    public String dynamicGet() { return "Base dynamicGet()"; }
}
class StaticSub extends StaticSuper {
    public static String staticGet() { return "Derived staticGet()"; }
    public String dynamicGet() { return "Derived dynamicGet(); }
}
public class Test {
    public static void main(String[] args) {
        StaticSuper sup = new StaticSub();
        System.out.println(sup.staticGet());  // Base staticGet() - 靜態綁定
        System.out.println(sup.dynamicGet()); // Derived dynamicGet() - 動態綁定
    }
}

構造器特殊規則

1. 構造器非多態

構造器本質是隱式 static 方法，不能被 override。子類構造器必須顯式或隱式調用父類構造器。

2. 父類構造器調用被覆蓋方法的陷阱

class Glyph {
    void draw() { System.out.println("Glyph.draw()"); }
    Glyph() {
        System.out.println("Glyph() before draw()");
        draw();  // 此處調用的是子類覆蓋的 draw()！
        System.out.println("Glyph() after draw()");
    }
}
class RoundGlyph extends Glyph {
    private int radius = 1;
    RoundGlyph(int r) { radius = r; System.out.println("RoundGlyph ctor, radius=" + radius); }
    void draw() { System.out.println("RoundGlyph.draw(), radius=" + radius); }
}
new RoundGlyph(5);
// 輸出：
// Glyph() before draw()
// RoundGlyph.draw(), radius=0   ← 半徑尚未初始化！
// Glyph() after draw()
// RoundGlyph ctor, radius=5

3. 構造器調用順序（必背）

1. 分配內存，二進制置 0
2. 調用父類構造器（遞歸至 Object）
3. 按聲明順序初始化成員變量/實例初始化塊
4. 執行子類構造器方法體

上例中步驟 2 調用 draw() 時，步驟 3 尚未執行，radius 仍為默認值 0。

字段訪問與 private 覆蓋陷阱

1. 字段無多態，編譯期解析

class Super { public int field = 0; public int getField() { return field; } }
class Sub extends Super { public int field = 1; public int getField() { return field; } }
Super sup = new Sub();
System.out.println(sup.field);      // 0 - 編譯期綁定 Super.field
System.out.println(sup.getField()); // 1 - 動態綁定 Sub.getField()

子類實際擁有兩個 field，需用 super.field 顯式訪問父類字段。

2. private 方法不可覆蓋

子類定義同名 private 方法屬於新方法，非覆蓋。編譯不報錯但運行行為違背預期。建議：子類避免使用與父類 private 方法同名的方法。

總結

• 封裝是基石，繼承是復用，多態是靈活性
• 動態綁定是多態運行時的核心機制
• 構造器調用鏈中調用可覆蓋方法是高危操作
• 字段訪問靜態綁定，切勿期望多態
• 理解這些底層機制，能寫出更健壯、可預測的 Java 代碼