Java 面向對象三大特性深度解析：封裝、繼承、多態與 super 關鍵字、方法重寫

在 Java 學習的進階階段，面向對象程式設計（OOP）的三大核心特性——封裝、繼承、多態，構成了建構健壯、可維護軟體架構的基石。本文將系統梳理這三大特性的核心概念、代碼實踐，並深入講解 super 關鍵字與方法重寫的關鍵細節，助你夯實 Java 基礎。

一、封裝：數據安全的守門人

封裝的核心思想是將數據（屬性）與操作數據的方法綁定在一起，並對外隱藏內部實現細節。通過權限修飾符控制訪問權限，實現數據的保護與模組化。

1. 權限修飾符

• public：公共訪問，無限制
• private：私有訪問，僅本類可見（注意：原文誤寫為「公有的」，此處已修正）
• protected：受保護訪問，同包及子類可見
• 默認（friendly）：包內訪問，同包可見

2. 封裝標準步驟

1. 使用 private 修飾需封裝的成員變量
2. 提供公共的 set/get 方法訪問屬性
   • 設置器：set屬性名()（屬性首字母大寫）
   • 訪問器：get屬性名()（屬性首字母大寫）

// 姓名設置器
public void setName(String name) {
    this.name = name;
}
// 姓名訪問器
public String getName() {
    return name;
}

3. 封裝實戰範例：Student 類

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

    // 構造方法
    public Student(String name, String sex) {
        this.name = name;
        if (sex.equals("男") || sex.equals("女")) {
            this.sex = sex;
        }
    }

    // 業務方法
    public void study() {
        System.out.println(name + "在學習");
    }

    // 性別設置器（含業務邏輯驗證）
    public void setSex(String sex) {
        if (sex.equals("男") || sex.equals("女")) {
            this.sex = sex;
        } else {
            System.out.println("輸入不合法，請重新輸入");
        }
    }

    public String getSex() { return sex; }
    public void setName(String name) { this.name = name; }
    public String getName() { return name; }
    public void setAge(int age) { this.age = age; } // 僅提供設置器
}

public class FengZhuangDemo {
    public static void main(String[] args) {
        Student star = new Student("星星", "性別"); // 非法性別
        star.study();
        System.out.println(star.getSex()); // 輸出 null
    }
}

4. 封裝的核心優勢

• 提升數據安全性：通過邏輯驗證防止非法數據寫入
• 隱藏實現細節：調用者無需關心內部邏輯
• 便於框架與工具類開發：標準化的 API 設計基石

思考：並非所有屬性都需要 set/get 方法，視業務需求而定（如唯讀屬性僅提供 getter）。

二、繼承：代碼復用的核心機制

繼承讓子類獲得父類的屬性與方法，實現代碼復用與擴展性。Java 單繼承（單根繼承），但支持多層繼承。

1. 基本語法與關係

class Person {
    String name;
    String sex;
    Dog dog; // 關聯關係：整體→部分

    public void eat() {
        System.out.println(name + "在吃飯");
    }
}

// 繼承關係：extends 關鍵字
class Student extends Person {
    int age;
    public void study() {
        System.out.println(name + "在學習"); // 直接訪問父類非私有屬性
    }
}

2. 繼承的關鍵規則

• 子類繼承父類非私有成員（屬性、方法）
• 構造方法不被繼承，但子類構造時默認調用父類無參構造（super()）
• 父類私有成員、構造方法、不同包下默認權限成員不可直接繼承
• 不要濫用繼承：必須滿足「is-a」邏輯關係

3. super 關鍵字詳解

super 代表父類對象引用，核心用途：

1. 訪問父類同名成員變量：super.屬性名
2. 調用父類構造方法：super(參數)，必須放在構造方法第一行

class Student extends Person {
    public Student(String name, String sex) {
        super(name, sex); // 顯式調用父類有參構造
        // this() 與 super() 不能同時出現
    }
}

4. 關聯關係 vs 繼承關係

關聯（Association）表現為「has-a」關係，如 Person 持有 Dog 對象，而非繼承。代碼示例：

class Person { Dog dog; }
class Dog { String name; void cry() {...} }

Person star = new Person();
star.dog = new Dog();
star.dog.cry(); // 星星的狗在叫

三、方法重寫：多態的基石

當父類方法無法滿足子類業務需求時，子類通過重寫（Override）重新實現方法。

重寫五大鐵律

1. 必須存在繼承關係
2. 方法名、參數列表完全一致
3. 子類權限 ≥ 父類權限（private < protected < public）
4. 子類返回值類型 ≤ 父類返回值類型（协变返回类型）
5. 子類拋出異常 ≤ 父類拋出異常

重寫 vs 重載

• 重寫：父子類間，方法簽名相同，行為不同
• 重載：同類內，方法名相同，參數列表不同（個數、類型、順序）

四、多態：一個接口，多種實現

多態定義：父類引用指向子類對象（Animal a = new Dog()）。

多態訪問規則（核心考點）

多態實戰：圖形面積計算

abstract class MyShape {
    public abstract void getArea();
    public abstract void getLength();
}

class Circle extends MyShape {
    int r; final double PI = 3.14;
    public void getArea() { System.out.println("圓的面積"); }
    public void getLength() { System.out.println("圓的周長"); }
}

class Rect extends MyShape {
    public void getArea() { System.out.println("矩形的面積"); }
    public void getLength() { System.out.println("矩形的周長"); }
}

public class PolyDemo {
    // 多態作為參數：接受任意圖形
    public static void getAreaAndLength(MyShape ms) {
        ms.getArea();
        ms.getLength();
    }

    // 多態作為返回類型
    public static MyShape getMyShape(int i) {
        return (i == 0) ? new Circle() : new Rect();
    }

    public static void main(String[] args) {
        getAreaAndLength(new Circle()); // 圓的面積/周長
        getAreaAndLength(new Rect());   // 矩形的面積/周長

        MyShape shape = getMyShape(0);
        // 向下轉型訪問子類特有功能
        Circle c = (Circle) shape;
    }
}

編譯與運行機制

• 編譯看左邊（引用類型）：檢查引用類型是否包含調用的成員
• 運行看右邊（對象類型）：實際調用對象類型的方法（非靜態方法）

總結

• 封裝守住數據安全邊界，規範 API 設計
• 繼承實現代碼復用，super 橋接父子類初始化
• 多態提升系統擴展性，配合重寫實現動態分派
• 掌握編譯期靜態綁定與運行期動態綁定的區別，是進階 Java 的關鍵

這三大特性相輔相成，構成了 Java 面向對象設計的鐵三角。深入理解其底層機制與最佳實踐，能讓你編寫出更優雅、健壯、可維護的代碼。