Java 抽象類與接口深度解析：OOP 三大特性的核心實現

面向對象編程（OOP）三大支柱——封裝、繼承、多態，在 Java 中通過類、抽象類、接口共同實現。本文系統梳理抽象類與接口的語法規則、設計哲學差異，並結合繼承、多態、封裝機制，構建完整知識體系。

一、抽象類

1. 核心概念

• 抽象方法：僅聲明無實現，abstract 返回類型 方法名(參數列表);
• 抽象類：包含抽象方法的類，或僅用 abstract 修飾的類（無抽象方法也可）。不能實例化，只能被繼承。
• 構造器：抽象類擁有構造器，供子類初始化父類字段（super(...)）。

2. 語法規範

public abstract class Animal {
    protected String name;
    public Animal(String name) { this.name = name; } // 構造器
    public abstract void sound(); // 抽象方法
    public void breathe() { System.out.println(name + " 呼吸中..."); } // 普通方法
}

3. 關鍵約束

二、接口

1. 定義與特性

• 行為契約：接口定義能做什麼，不關心怎麼做。
• 默認修飾符：方法隱式 public abstract，字段隱式 public static final（常量）。
• Java 8+ 增強：支持 default 默認方法、static 靜態方法、private 私有方法。

2. 語法示例

public interface Flyable {
    void fly(); // 隱式 public abstract
    default void land() { System.out.println("著陸"); } // 默認方法
    static int maxHeight() { return 10000; } // 靜態方法
}

三、抽象類 vs 接口：雙維度對比

1. 語法層面

2. 設計層面（核心差異）

3. 經典類比：鳥與飛行

// 抽象類：鳥類整體抽象
abstract class Bird {
    protected String name;
    public Bird(String name) { this.name = name; }
    public abstract void breed(); // 繁殖方式各異
}

// 接口：飛行能力
interface Flyable {
    void fly();
}

// 具體鳥類
class Eagle extends Bird implements Flyable {
    public Eagle() { super("老鷹"); }
    public void breed() { System.out.println("產卵孵化"); }
    public void fly() { System.out.println("高空滑翔"); }
}

class Penguin extends Bird { // 不實現 Flyable
    public Penguin() { super("企鵝"); }
    public void breed() { System.out.println("產卵孵化"); }
}

四、繼承機制詳解

1. 核心特點

• 子類擁有父類 non-private 字段/方法
• 子類可擴展新字段/方法
• 子類可重寫 父類方法（多態基石）
• 構造器不繼承，但子類構造器必須調用 super()
• 關鍵字：extends

2. 重寫 vs 重載

3. 對象成員查找：就近原則

this → super → super.super → ...，編譯期綁定靜態方法/字段，運行期綁定實例方法。

五、多態深度剖析

1. 三大必要條件

1. 繼承/實現關係
2. 方法重寫
3. 父類引用指向子類對象（Animal a = new Dog();）

2. 動態綁定本質

JVM 根據對象實際類型而非引用類型分發方法調用。a.sound() 調用 Dog.sound()。

3. 靜態綁定例外

• 靜態方法：按引用類型調用（隱藏而非重寫）
• 私有方法：不可見，無多態
• 構造器：無多態
• 字段：按引用類型訪問（無多態）

4. 多態參數與返回類型

// 參數多態：接受所有 Animal 子類
public void feed(Animal a) { a.eat(); }

// 返回類型多態：工廠模式
public Animal create(String type) {
    if ("dog".equals(type)) return new Dog();
    return new Cat();
}

5. 經典多態解析案例

參考原文 A/B/C/D 繼承鏈與重載/重寫混合場景，核心判斷邏輯：

1. 編譯期看引用類型確定候選方法集（含重載）
2. 運行期看對象實際類型從候選集中選擇重寫版本
3. 優先級：this.show(O) → super.show(O) → this.show((super)O) → super.show((super)O)

六、封裝

1. 核心思想

將數據與操作綁定，隱藏內部實現，暴露受控接口。四大收益：

• 降低耦合
• 內部結構自由變更
• 精確控制字段訪問（驗證、懶加載、只讀）
• 信息隱藏，實現細節隔離

2. 訪問修飾符矩陣

3. 封裝最佳實踐

public class Student {
    private String name;
    private int age;

    // 內部邏輯封裝
    private String formatName(String n) { return "Student: " + n; }
    private String formatAge(int a) { return a + " 歲"; }

    // 對外接口
    public String getName() { return name; }
    public void setName(String name) { this.name = formatName(name); }
    public int getAge() { return age; }
    public void setAge(int age) { 
        if (age > 0 && age < 150) this.age = age; // 驗證
    }
}

總結

抽象類與接口是 Java 實現多態與擴展性的雙引擎。抽象類捕捉「是什麼」（共性結構），接口定義「能做什麼」（行為契約）。繼承實現代碼復用，多態實現運行時綁定，封裝守護內部不變量。掌握三者協作，方能設計出高內聚、低耦合、易演進的面向對象系統。