Java 繼承中構造器調用機制深度解析

核心規則速覽

1. 子類構造器必須調用父類構造器（顯式或隱式）。
2. super(args) 必須是子類構造器第一條語句；this(args) 調用本類其他構造器，亦必須首行。
3. 若無顯式 super(...)，編譯器自動插入 super()（調用父類無參構造器）。
4. 若父類只有帶參構造器，子類必須顯式 super(args)，否則編譯失敗。

代碼演示：四種調用場景

class SuperClass {
    private int n;
    // 無參構造器被註釋掉 → 父類無無參構造器
    // SuperClass() { System.out.println("SuperClass()"); }

    SuperClass(int n) {
        System.out.println("SuperClass(int n): " + n);
        this.n = n;
    }
}

class SubClass extends SuperClass {
    private int n;

    // 1. 顯式調用父類帶參構造器
    SubClass() {
        super(300); // 必須首行
        System.out.println("SubClass() 無參");
    }

    // 2. 顯式調用父類帶參構造器 + 子類帶參
    SubClass(int n) {
        super(n * 2); // 計算後傳給父類
        System.out.println("SubClass(int n): " + n);
        this.n = n;
    }

    // 3. 鏈式調用本類無參構造器
    SubClass(String msg) {
        this(100); // 調用 SubClass(int)
        System.out.println("SubClass(String): " + msg);
    }
}

public class TestSuperSub {
    public static void main(String[] args) {
        System.out.println("=== new SubClass(200) ===");
        new SubClass(200);
        System.out.println("\n=== new SubClass(\"Hello\") ===");
        new SubClass("Hello");
    }
}

運行輸出與調用鏈分析

=== new SubClass(200) ===
SuperClass(int n): 400   ← super(200*2)
SubClass(int n): 200

=== new SubClass("Hello") ===
SuperClass(int n): 200   ← this(100) → super(100*2)
SubClass(int n): 100
SubClass(String): Hello

常見編譯錯誤案例

錯誤 1：父類無無參構造器，子類未顯式 super

class Parent { Parent(int x) {} }
class Child extends Parent { 
    Child() { } // 編譯錯誤：Implicit super constructor Parent() is undefined
}

修正

Child() { super(0); } // 或 Child(int x) { super(x); }

錯誤 2：super() 不在首行

Child() {
    System.out.println("init"); // 編譯錯誤
    super(0);
}

最佳實踐建議

1. 父類保留無參構造器（或提供無參重載），降低子類耦合。
2. 構造器鏈集中邏輯：用 this(...) 避免重複初始化代碼。
3. 不要在構造器中調用可覆寫方法：子類字段尚未初始化，導致 NPE 或邏輯錯誤。
4. 不可變類模式：所有字段 final，構造器一次性初始化，無 setter。

總結

構造器調用鏈是繼承初始化的骨幹。牢記「super 必須首行、父類無無參則子類必須顯式調用」、善用 this(...) 避免重複，能消除 90% 繼承初始化坑點。