您现在的位置：程式碼之家 >> 編程語言 > >> Java 程式設計 >> Java 綜合教學

Java 多態核心機制深度解析：繼承、重寫、向上轉型與動態分派全圖譜

編輯：Java 綜合教學

Java 多態核心機制深度解析

多態是面向對象三大特性 (封裝、繼承、多態) 中最具威力、也是最易混淆的概念。本文從「三大支柱」切入，結合內存模型、方法調用規則、向上/向下轉型實戰，為你構建完整的多態知識體系。

多態三大支柱：缺一不可

🧬 1. 繼承

基礎：子類繼承父類非私有成員

class Animal {
    void eat() { System.out.println("動物進食"); }
}

class Bird extends Animal {
    // 繼承了 eat()，可直接調用
}

extends 關鍵字實現
單繼承，多層繼承
子類擁有父類非 private 成員

🔄 2. 方法重寫

核心：子類重新定義父類方法

class Bird extends Animal {
    @Override
    void eat() { 
        System.out.println("鳥吃蟲子"); // 具體實現
    }
}

方法簽名完全相同 (名稱/參數/返回類型)
@Override 註解編譯期檢查
訪問權限 ≥ 父類 (public > protected > default)
拋出異常 ≤ 父類

🔀 3. 父類引用指向子類對象

形式：向上轉型

Animal animal = new Bird(); // 核心語法
animal.eat(); // 輸出: 鳥吃蟲子

編譯看左邊 (父類類型)
運行看右邊 (子類對象)
自動向上轉型 (隱式)
向下轉型需強制 (Bird) animal

內存模型視角：多態如何工作

棧內存 (引用)          堆內存 (對象)           方法區 (類元數據)
┌──────────────┐       ┌──────────────┐       ┌──────────────┐
│ Animal a     │ ───►  │ Bird 对象    │       │ Animal.class │
│              │       │ - vptr ──────┼───►   │ - eat()      │
└──────────────┘       └──────────────┘       │ Bird.class   │
                                               │ - eat() ◄───┐│
                                               └──────────────┘│
                                                                 │
                              ┌─────────────────────────────────┘
                              ▼
                    虛方法表 - 動態分派核心
                    ┌──────────────────┐
                    │ Animal.eat → 0x1 │
                    │ Bird.eat   → 0x2 │  ◄─── 運行時解析到此入口
                    └──────────────────┘

關鍵結論

非靜態方法：運行時根據對象實際類型動態分派 (虛方法表)
靜態方法/私有方法/構造器：編譯期根據引用類型靜態分派
字段訪問：編譯期根據引用類型解析，無多態

方法調用規則詳解

場景	父類方法	子類方法	調用結果
重寫	有	有 (同簽名)	✅ 調用子類方法 (動態分派)
未重寫	有	無	✅ 調用父類方法 (繼承)
子類特有	無	有	❌ 父類引用無法調用 (編譯錯誤)
靜態方法同名	static	static	⚠️ 隱藏而非重寫，調用引用類型方法

代碼驗證

class Animal {
    public void eat() { System.out.println("動物進食"); }
    public static void breathe() { System.out.println("動物呼吸"); }
}

class Bird extends Animal {
    @Override
    public void eat() { System.out.println("鳥吃蟲子"); }
    public static void breathe() { System.out.println("鳥呼吸"); } // 隱藏
    public void fly() { System.out.println("鳥飛翔"); } // 子類特有
}

public class PolyTest {
    public static void main(String[] args) {
        Animal a = new Bird();
        
        a.eat();        // ✅ 輸出: 鳥吃蟲子 (動態分派)
        a.breathe();    // ⚠️ 輸出: 動物呼吸 (靜態分派，看引用類型)
        // a.fly();     // ❌ 編譯錯誤: Animal 無 fly 方法
        
        // 向下轉型調用子類特有方法
        if (a instanceof Bird) {
            Bird b = (Bird) a;
            b.fly();    // ✅ 輸出: 鳥飛翔
        }
    }
}

向上/向下轉型完整指南

向上轉型 - 自動、安全

Animal animal = new Bird();        // 隱式向上轉型
Animal animal2 = (Animal) new Bird(); // 顯式向上轉型 (冗余)

// 好處：統一管理異構對象
List<Animal> zoo = Arrays.asList(
    new Bird(), new Fish(), new Mammal()
);
zoo.forEach(Animal::eat); // 多態調用各自實現

向下轉型 - 手動、有風險

Animal animal = new Bird();

// ❌ 危險：運行時可能拋 ClassCastException
Fish fish = (Fish) animal; 

// ✅ 安全模式：instanceof 守衛
if (animal instanceof Bird) {
    Bird bird = (Bird) animal;
    bird.fly();
}

// ✅ Java 14+ 模式匹配 (更簡湜)
if (animal instanceof Bird bird) {
    bird.fly();
}

多態的實戰價值：OCP 原則落地


// ❌ 違反開閉原則：新增動物需修改此方法
void feedAnimal(Animal animal) {
    if (animal instanceof Bird) { ... }
    else if (animal instanceof Fish) { ... }
    // ...
}

// ✅ 符合開閉原則：利用多態擴展
interface Feedable {
    void feed(Food food);
}

class Bird implements Feedable {
    public void feed(Food food) { /* 鳥餵食邏輯 */ }
}

class ZooKeeper {
    public void feed(Feedable animal, Food food) {
        animal.feed(food); // 多態調用，無需知道具體類型
    }
}

進階陷阱：字段遮蔽 vs 方法重寫

class Parent {
    String name = "Parent";
    void print() { System.out.println("Parent.print()"); }
}

class Child extends Parent {
    String name = "Child"; // 字段遮蔽，非重寫
    void print() { System.out.println("Child.print()"); } // 方法重寫
}

Parent p = new Child();
System.out.println(p.name); // 輸出: Parent (字段看引用類型)
p.print();                  // 輸出: Child.print() (方法看對象類型)