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 呼叫發生得太早,你只會更快拿到例外。 正確的治療方式不是「把初始化延後得更晚」,而是基底類在自身建立時不應依賴覆寫,並充分考慮階層中的初始化順序。
GO TO FULL VERSION