Java 多態深度解析：編譯時/運行時多態、重載/重寫、虛擬方法表與經典面試題

多態核心定義

多態：同一介面，多種實現。Java 兩大多態：

• 編譯時多態 (靜態綁定)：方法重載。編譯器根據參數列表決定調用哪個方法。
• 運行時多態 (動態綁定)：方法重寫。JVM 根據物件實際類型決定調用哪個方法。

運行時多態三大必要條件

1. 繼承/實現關係：子類 extends 父類 / implements 介面
2. 方法重寫：子類重新定義父類方法 (同簽名、兼容返回型別、不拋更寬檢查異常)
3. 父類引用指向子類物件：Parent p = new Child(); (向上轉型)

動態分派機制：虛擬方法表 (vtable)

// 簡化原理圖解
class Animal {
    void sound() { System.out.println("動物聲音"); }
    void breathe() { System.out.println("呼吸"); }
}

class Dog extends Animal {
    @Override void sound() { System.out.println("汪汪"); }
    void fetch() { System.out.println("撿球"); }
}

// JVM 內部為每個類建立 vtable (方法表)
// Animal vtable: [sound()->Animal.sound, breathe()->Animal.breathe]
// Dog vtable:    [sound()->Dog.sound,    breathe()->Animal.breathe] (繼承)

// 執行時：
Animal a = new Dog();
a.sound(); // 1. 取得 a 實際類型 Dog
           // 2. 查 Dog vtable 中 sound 入口
           // 3. 調用 Dog.sound() → 輸出 "汪汪"
// 注意：a.fetch() 編譯錯誤！Animal 引用不可見子類特有方法

方法重載 vs 重寫 完整對比

經典面試題：重載與重寫混合陷阱

class A {
    public String show(D obj) { return "A and D"; }
    public String show(A obj) { return "A and A"; }
}
class B extends A {
    public String show(B obj) { return "B and B"; }  // 重載 (參數不同)
    @Override public String show(A obj) { return "B and A"; } // 重寫
}
class C extends B {}
class D extends B {}

// 測試
A a1 = new A();
A a2 = new B();
B b = new B();
C c = new C();
D d = new D();

System.out.println(a1.show(b)); // ①
System.out.println(a1.show(c)); // ②
System.out.println(a1.show(d)); // ③
System.out.println(a2.show(b)); // ④
System.out.println(a2.show(c)); // ⑤
System.out.println(a2.show(d)); // ⑥
System.out.println(b.show(b));  // ⑦
System.out.println(b.show(c));  // ⑧
System.out.println(b.show(d));  // ⑨

答案與解析

方法調用優先級規則 (由高到低)

1. this.show(O)：當前類精確匹配參數類型
2. super.show(O)：父類精確匹配
3. this.show((super)O)：當前類匹配參數的父類型
4. super.show((super)O)：父類匹配參數的父類型

關鍵：編譯器根據引用變數編譯時類型的參數類型進行靜態綁定 (選擇重載)；運行時根據物件實際類型進行動態綁定 (選擇重寫)。

多態的五大優勢

1. 可替換性：子類可替換父類使用 (里氏替換原則)
2. 可擴充性：新增子類不修改既有代碼 (開閉原則)
3. 介面性：父類定義契約，子類實現細節
4. 靈活性：運行時動態決定行為
5. 簡化性：統一處理異構物件集合

實戰應用：策略模式 + Spring 依賴注入

// 1. 定義介面 (契約)
interface PaymentStrategy {
    void pay(BigDecimal amount);
}

// 2. 多種實現
@Component("alipay") class AlipayStrategy implements PaymentStrategy { ... }
@Component("wechat") class WechatStrategy implements PaymentStrategy { ... }
@Component("unionpay") class UnionPayStrategy implements PaymentStrategy { ... }

// 3. 上下文使用多態
@Service
class PaymentService {
    private final Map strategies;

    // Spring 自動注入所有實現到 Map (key 為 @Component value)
    public PaymentService(Map strategies) {
        this.strategies = strategies;
    }

    public void process(String channel, BigDecimal amount) {
        PaymentStrategy strategy = strategies.get(channel);
        if (strategy == null) throw new IllegalArgumentException("不支援管道: " + channel);
        strategy.pay(amount); // 多態調用
    }
}

// 4. 新增管道只需新增實現類，零修改既有代碼

常見誤區與避坑

• 私有方法不可重寫：private 方法隱式 final，子類同名方法是新方法非重寫
• 靜態方法不可重寫：static 方法屬於類，子類同名是隱藏非重寫，調用由編譯類型決定
• 建構子不可重寫：建構子非成員方法，無多態
• 欄位無多態：parent.field 總是訪問編譯類型的欄位 (隱藏非重寫)
• final 方法不可重寫：編譯器直接內聯/靜態綁定
• 預設方法衝突：實現多個介面有同名 default 方法需顯式重寫指定調用哪個