CodeGym /課程 /Kotlin SELF /super 與初始化順序:擴充基礎邏輯

super 與初始化順序:擴充基礎邏輯

Kotlin SELF
等級 35, 課堂 2
開放

1. 介紹

在上一講中,我們學會了透過 override 覆寫方法與屬性,並透過 open 開啟需要的擴充點;也認識了 protected,其含義是「對子類可見,但對外部世界不可見」。 今天我們要在此基礎上加入一個重要的實務技能:當你覆寫行為時,如何不破壞基礎邏輯;以及為什麼有時 super 不是「我投降了」,而是「我做對了」。 另外我們也會拆解初始化順序——它常讓新手產生「Kotlin 在嘲諷我」的感覺。

當你覆寫一個方法時,很容易產生一種衝動:「好,現在我才是老大,基底類可以退休了。」 但在真實程式碼裡,基底類往往做了很重要的事:檢查輸入、正規化文字、寫 log、計算某些欄位、維護不變量(invariants)。 如果你把這些行為「剪掉」,程式可能開始用很奇怪的方式運作——而且完全不會有編譯錯誤。 這時 super 就像一個有禮貌的人,會說:「先完成基礎部分,再加上我的部分。」

在 Kotlin 中,關鍵字 super 允許你在被覆寫的成員中呼叫基底類的實作(方法或屬性的 accessor)。 官方的表述通常大意是:「子類的程式碼可以透過 super 呼叫超類的實作。」

最重要的一句話是:super 並非永遠都需要,但如果基底類負責一些必要步驟,那麼 super 就是用來擴充而不是破壞的方式。

2. 在覆寫方法中使用 super

現實通常丟給我們的不是「把方法整個替換掉」,而是「做一樣的事,但再多一點點」。 例如:基底類已經會印出訊息,而子類想加上前綴。 或是:基底類負責驗證字串,子類再補一個額外檢查,同時仍想重用基底類的驗證。

先看一個最小示例,找一下感覺:

open class Logger {
    open fun log(message: String) {
        println("[LOG] $message")
    }
}

class TaggedLogger : Logger() {
    override fun log(message: String) {
        super.log("TAG: $message")
    }
}

fun main() {
    val logger = TaggedLogger()
    logger.log("Hello")
    // [LOG] TAG: Hello
}

這裡子類不重新發明「怎麼印 log」,而是使用既有的輸出方式,並加上自己的標記。

現在把這個想法搬到我們的教學情境(支出記帳的主控台應用程式)。 假設我們想印出「報表行」。 基底類負責共通格式(例如相同縮排與符號),而子類補上具體內容。

open class ReportLine {
    open fun render(): String = "- (empty)"
}

class TextLine(private val text: String) : ReportLine() {
    override fun render(): String = super.render() + " $text"
}

fun main() {
    val line = TextLine("hello")
    println(line.render())
    // - (empty) hello
}

這個例子故意有點「蠢」,但它展示了機制:super.render() 是格式的基礎部分,後面再加上自己的內容。 在真實情境中,基底 render() 會做比輸出 "empty" 更有用的事;也正因此,我們更值得透過 super 來擴充,而不是把格式複製到所有子類裡。

再生活化一點:基底類保證報表行永遠不為空(例如回傳 "(no data)"),子類在不違反這個契約的前提下增加細節。

3. super 與屬性:存取 getter

新手常覺得屬性是「只是欄位」,方法才是「邏輯」。 在 Kotlin 裡這是個危險的錯覺:屬性幾乎總是意味著getter(有時也有 setter),也就是「底層有個小方法」。 因此 super.someProp 不是魔法,而是「呼叫基底類的 getter 實作」。

在繼承相關文件中通常會這樣示範:子類可以透過 super.property 存取超類的屬性,並把它當作自身邏輯的一部分。

例子:

open class Document {
    open val title: String = "Untitled"
}

class NamedDocument(private val name: String) : Document() {
    override val title: String
        get() = super.title + ": " + name
}

fun main() {
    val doc = NamedDocument("Budget report")
    println(doc.title)
    // Untitled: Budget report
}

注意一個細節:我們覆寫 val title 不是用「儲存值」,而是用 get()。 當「值」需要計算而不是儲存時,這非常方便。 而且,是的:這裡的 super.title 會呼叫基底的 getter。

在真實專案中,這常用來「擴充描述」: 基底類提供通用部分,子類再加上尾巴。 如果基底類的描述本身也是計算出來的(而不只是儲存),super 就能幫你重用這段基礎邏輯。

4. 繼承中的初始化順序

在進入陷阱之前,先把物件究竟以什麼順序被建立釐清:當存在基底類與子類時,初始化會怎麼走。 許多與繼承相關的 bug 看起來都像是:「為什麼我的欄位還是 0/null?我明明已經賦值了!」而答案幾乎永遠是:初始化順序。

直覺規則是:建立子類物件時,會先建立物件的「基底部分」,然後才建立「子類部分」。 這聽起來合理,但有重要細節:在初始化基底類之前,還會先計算呼叫其建構子所需的引數。 Kotlin 的描述很直接:基底初始化會先執行(除了用來呼叫超類建構子的引數計算),這也意味著當基底建構子或 init 執行時,子類中被覆寫的屬性尚未初始化。

來看一個示範例子,透過列印步驟觀察順序。 這裡刻意使用 also { println(...) },用來顯示「到底何時計算了什麼」:

open class Base(name: String) {
    init {
        println("Base.init, name=$name")
    }

    open val size: Int = name.length.also {
        println("Base.size initialized: $it")
    }
}

class Derived(name: String, private val lastName: String) : Base(
    name.uppercase().also { println("Argument for Base: $it") }
) {
    init {
        println("Derived.init, lastName=$lastName")
    }

    override val size: Int = (super.size + lastName.length).also {
        println("Derived.size initialized: $it")
    }
}

fun main() {
    println("Constructing...")
    Derived("hello", "world")
}

預期輸出(大概長這樣;順序比具體文字更重要):

Constructing...
Argument for Base: HELLO
Base.init, name=HELLO
Base.size initialized: 5
Derived.init, lastName=world
Derived.size initialized: 10

如果把「發生的骨架」抽出來,會得到這樣的流程:

flowchart TD
    A["建立 Derived(...)"] --> B["計算 Base(...) 的引數"]
    B --> C["初始化 Base:屬性 + init 區塊"]
    C --> D["初始化 Derived:屬性 + init 區塊"]

也正因如此,基底類在設計上必須小心:在它的初始化期間,子類還沒有「組裝完成」。

另外,如果你想快速確認自己程式碼中的順序,把 println 放在 init { } 裡就是很誠實的除錯工具。 Kotlin 不會譴責你(但你未來的 team lead 可能會小小譴責一下——那又是另一個故事了)。

5. 為什麼在 init 中呼叫 open 很危險

現在進入重點:繼承不再像可愛小貓,而變成那種會把杯子從桌上推下去、還一臉「你能拿我怎樣」的小貓。 問題在於:如果基底類在 init 裡呼叫 open 方法,或存取 open 屬性,Kotlin 可能會呼叫到子類的覆寫版本——即使子類還來不及初始化自己的欄位。

這不是「編譯器特性」,而是多型的邏輯結果:呼叫必須落到最具體的實作上。 文件也明確警告:在設計基底類時,應避免在建構子、屬性初始化器以及 init 區塊中使用 open 成員。

來看一個看似無害、但可能出事的例子:

open class BaseGreeter {
    init {
        // Bad idea: the open method will be called at a moment
        // when the subclass may not be ready yet.
        println(buildGreeting())
    }

    open fun buildGreeting(): String = "Hello from Base"
}

class FancyGreeter : BaseGreeter() {
    private val prefix: String = "[Fancy]"

    override fun buildGreeting(): String = "$prefix Hello from Fancy"
}

fun main() {
    FancyGreeter()
}

乍看之下一切正常:prefix 不是宣告了嗎? 但順序是:BaseGreeter.init 會先於 FancyGreeter 的初始化(其屬性與 init)執行。 在某些情況下,這會讓覆寫方法試圖使用尚未就緒的狀態。

為了讓問題更直觀、並且保證能得到錯誤,我們改用 lateinit。 這是很真實的情境:你延後初始化,但如果太早呼叫就會丟例外。

open class BaseFormatter {
    init {
        println(format()) // risk
    }

    open fun format(): String = "(base)"
}

class UserFormatter : BaseFormatter() {
    private lateinit var userName: String

    init {
        userName = "Alice"
    }

    override fun format(): String = "User=$userName"
}

fun main() {
    UserFormatter()
    // UninitializedPropertyAccessException: lateinit property userName has not been initialized
}

這就是那個經典瞬間:「為什麼它會跑去呼叫子類?」 因為方法是 open,而實際物件是 UserFormatter。

要怎麼修? 思路很簡單:基底類不應該在自己的初始化階段依賴子類覆寫。 一個安全做法是:在基底類中做一個final 方法(不開放覆寫)並在 init 裡呼叫;而擴充點則放到另一個位置,等物件確定組裝完成後再呼叫。

例如:基底 init 只印出基礎部分,而「額外部分」可以在物件建立之後再呼叫(從外部程式碼,或在子類 init 中、當它已就緒時呼叫)。

open class SafeBaseFormatter {
    init {
        println(baseFormat()) // base part, not open
    }

    fun baseFormat(): String = "(base safe)"
}

class SafeUserFormatter : SafeBaseFormatter() {
    private val userName: String = "Alice"

    fun fullFormat(): String = "User=$userName"
}

fun main() {
    val f = SafeUserFormatter()
    println(f.fullFormat()) // User=Alice
}

是的,這樣比較不「魔法」,但它可預測。 而可預測性基本上就是程式設計的主要貨幣(咖啡之後的那種)。

6. 專案中的一小步:格式化報表行

為了把主題落地,不只停留在抽象的「方塊」,我們把 super 套進支出記帳主控台應用的小片段。 假設我們已經有支出清單並在列印報表。 我們希望所有報表行都有一致風格:縮排、標記、長度限制;並且子類能在不手動複製風格的前提下加上細節。

我們做一個基底類 ReportLine,它知道怎麼產生「行的抬頭」,子類再補上內容:

open class ReportLine {
    protected fun bullet(): String = "•"

    open fun render(): String = "${bullet()} "
}

class TextReportLine(private val text: String) : ReportLine() {
    override fun render(): String = super.render() + text
}

fun main() {
    println(TextReportLine("Expenses").render())
    // • Expenses
}

這裡已經能看到今天的兩個重點:super.render() 加上共通部分,而 protected 讓「服務用」的 bullet() 對子類可用、但對外部不可見。

接著加一行「合計」,我們想強化格式:基礎部分保持共通,但額外加上 "TOTAL"。 這裡刻意展示:super 可以在字串中間呼叫——它就是普通函式呼叫而已。

class TotalReportLine(private val total: Int) : ReportLine() {
    override fun render(): String = super.render() + "TOTAL = $total"
}

fun main() {
    println(TotalReportLine(1200).render())
    // • TOTAL = 1200
}

再來示範一個 super 用在屬性中的情境,因為「標題」也很適合做成屬性:

open class TitledLine {
    open val title: String = "line"

    open fun render(): String = "[$title]"
}

class CategoryLine(private val category: String) : TitledLine() {
    override val title: String
        get() = super.title + ":" + category
}

fun main() {
    println(CategoryLine("Food").render())
    // [line:Food]
}

這裡的 super.title 會存取基底 getter。 即使基底 title 之後改成計算型屬性,子類的程式碼也不需要重寫。

最後一個小結論:super 能讓報表的共通風格只住在一個地方。 當你想把標記從 "•" 改成 "-" 時,不必在專案裡找 15 份重複的格式化程式碼。

什麼時候該呼叫 super,什麼時候不該

在真實世界,「永遠呼叫 super」是壞建議,「永遠不呼叫 super」也一樣。 需要一個務實標準:基底實作是否是必要契約的一部分,還是你真的要完全替換它。

可以在腦中放一張小表:

情境 通常代表什麼 更常見的做法
基底方法做資料驗證、記錄 log、更新計數器 重要的基礎設施,沒有它類別可能會「壞掉」 呼叫 super,並在前/後加上自己的部分
基底方法回傳「佔位」或預設值 基底不承載實質意義,只是「讓它存在」 可以完全替換,不呼叫 super
覆寫改變格式,但共通骨架一致 共通部分對所有子類都需要 super + 加上擴充
基底類在 init 中呼叫 open 方法 子類可能被過早呼叫的風險 重設設計:這種情況 super 也救不了

還有一條值得貼在螢幕旁的規則:如果基底類做了影響正確性的關鍵工作,而你沒有呼叫 super,你的程式可能會「幾乎總是正常」——這是最陰險的壞掉模式。

7. 常見錯誤

錯誤 1:「我覆寫了方法——所以基底邏輯不需要了。」
這種做法常會破壞基底類的不變量:例如它會正規化輸入、維護計數器、填入內部欄位,或印出報表的必要部分。 如果你不呼叫 super,你不只是「改變行為」,而可能是不小心取消了契約中重要的一部分。

錯誤 2:在「不對的位置」呼叫 super,導致邏輯變得奇怪。
有時順序非常重要:基底方法可能假設它的呼叫是第一步(例如先檢查引數),或相反地假設它是最後一步(例如收尾狀態)。 如果你在做完依賴基礎準備的操作之後才呼叫 super,就會得到那種「看起來都對,但結果歪掉」的 bug。

錯誤 3:存取 super.someProperty,卻以為那只是欄位而不是計算。
在 Kotlin 中,屬性本質上就是 get()/set() 方法。 super.title 可能是計算型,可能會讀取其他欄位,甚至可能有副作用(雖然不建議這麼做)。 因此你應該把 super.property 當作邏輯呼叫,而不是單純讀取記憶體。

錯誤 4:在基底類的 init 裡呼叫 open 方法/屬性。
這是最惱人的「專業級」bug 之一:程式能編譯,有時甚至能跑,但當子類變得更複雜就開始因為「欄位尚未就緒」而崩潰。 Kotlin 文件對此模式有明確警告:設計基底類時,最好避免在建構子與 init 中做 open 呼叫。

錯誤 5:想用「再加一個 lateinit」來治初始化順序問題。
lateinit 是有用的工具,但它不會讓初始化順序更安全。 相反地:如果 open 呼叫發生得太早,你只會更快拿到例外。 正確的治療方式不是「把初始化延後得更晚」,而是基底類在自身建立時不應依賴覆寫,並充分考慮階層中的初始化順序。

1
任務
Kotlin SELF, 等級 35, 課堂 2
上鎖
朋友問候
朋友問候
1
任務
Kotlin SELF, 等級 35, 課堂 2
上鎖
筆記標題
筆記標題
1
任務
Kotlin SELF, 等級 35, 課堂 2
上鎖
初始化追蹤
初始化追蹤
1
任務
Kotlin SELF, 等級 35, 課堂 2
上鎖
安全的格式化器
安全的格式化器
留言
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION