1. 前言
當你剛開始寫程式時,會覺得一個類別就代表「一種角色」。但現實很快會證明相反:同一個物件可以同時是「能印到主控台的東西」、「能序列化成 CSV 的東西」、「可以被記錄(logging)的東西」、「可以被驗證(validation)的東西」。如果你試圖把所有能力都塞進一個介面 EverythingEverywhereAllAtOnce,你得到的不是架構,而是一桌把所有菜都端上來的方法自助餐。
核心想法:介面保持精簡、聚焦在單一主題會更舒服。這樣一個類別就能同時實作多個小型契約。Kotlin 允許這麼做: class X : A, B, C. 問題不在於「多重」本身,而在於契約有時會在名稱與簽名上重疊。這時編譯器就會成為你嚴格的編輯:「這一幕有兩位演員同時念了台詞 render()——我們要聽誰的?」
Kotlin 的基本規則:禁止歧義
這條規則很值得像交通標誌一樣牢記。
如果一個類別從其直接超型(supertype)繼承了同一個成員(函式或屬性)的多個實作,Kotlin 會強制你寫 override,並由你親自定義最終行為。
這同時適用於「兩個 default 實作」以及「一個介面提供 default,而另一個介面只有宣告(抽象)」。Kotlin 文件的說法是:在多重繼承實作時需要明確消除歧義;要選擇特定實作,需使用具限定(qualified)的 super<...>。
一個重要的心理設定:編譯器不是在刁難你,它是在保護你(以及未來的你),避免「反正它會自己選到某個實作吧」這種魔法。在那些會「自動處理」的語言裡,之後往往會誕生傳奇 bug——它們通常一路活到第一次上線版本。
2. default 方法衝突與 super<...>
兩個 default 方法的衝突
想像有兩個介面,兩者都給了同一個方法 ping() 的 default 實作:
interface A {
fun ping(): String = "A"
}
interface B {
fun ping(): String = "B"
}
接著我們想做一個同時實作兩者的類別:
class C : A, B // <- 這裡就會開始有問題
在 Kotlin 看來這是「那你到底要繼承哪個 ping()?」的情境。如果編譯器默默選了其中一個,你之後就會花很久解釋給自己聽,為什麼「有時候會印出 A」。因此 Kotlin 會要求:
- 明確寫出 override fun ping(),
- 並在方法內(如果需要)選擇要呼叫哪個實作。
而今天的主角就在這裡登場:super<InterfaceName>.method()。
super<...>:如何說「就從這裡拿實作」
不帶限定的 super 在繼承關係明確時可用(例如一般情況:類別只繼承一個基底類別,且只有一個 super 來源)。但當同一方法有多個來源時,Kotlin 會要求你在角括號內加上限定: super<A>.ping()。
範例:「把」兩個介面的行為「黏合」起來:
interface A {
fun ping(): String = "A"
}
interface B {
fun ping(): String = "B"
}
class C : A, B {
override fun ping(): String {
return super<A>.ping() + super<B>.ping()
}
}
fun main() {
val c = C()
println(c.ping()) // AB
}
從閱讀程式碼的角度來說這很方便:你打開方法就能立刻看到「最終行為是 A 與 B 的組合」。沒有任何巫術。
3. 其他類型的衝突
default + 抽象方法:「看起來有實作,但仍然需要 override」
這是最常見的「新手陷阱」。
想像一個介面提供 default 實作,而另一個介面只要求該方法(沒有方法體):
interface WithDefault {
fun value(): Int = 10
}
interface MustImplement {
fun value(): Int
}
你可能會想:「不是已經有現成實作了,編譯器還想要什麼?」但 Kotlin 的觀點是:兩個介面都宣告了同一個成員,因此在類別中必須明確固定最終行為是什麼。
你會寫:
class D : WithDefault, MustImplement {
override fun value(): Int = super<WithDefault>.value()
}
fun main() {
val d = D()
println(d.value()) // 10
}
為什麼這樣更好?因為 MustImplement 是一個契約:「必須有人賦予 value() 意義」。如果你「默默地」拿到 WithDefault 的實作,閱讀程式碼的人可能沒注意到這個類別滿足 MustImplement 並非靠自身邏輯,而是「順手接了」別人的。Kotlin 強迫你把這件事寫明白:要嘛你寫自己的實作,要嘛你明確表示「是的,我採用 WithDefault 的預設實作」。
類別與介面之間的衝突
「菱形」也可能長這樣:有一個基底類別(帶實作),同時也有一個介面(也帶同名方法的實作)。Kotlin 會把它視為來自兩個來源的兩個實作——因此 override 是必須的。
迷你範例:
open class BaseLogger {
open fun tag(): String = "BASE"
}
interface UiTaggable {
fun tag(): String = "UI"
}
class ScreenLogger : BaseLogger(), UiTaggable {
override fun tag(): String {
return super<BaseLogger>.tag() + "-" + super<UiTaggable>.tag()
}
}
fun main() {
val logger = ScreenLogger()
println(logger.tag()) // BASE-UI
}
一個有用的習慣:當你看到 class X : SomeClass(), A, B 時,要記得衝突不只可能發生在 A 與 B 之間,也可能發生在 SomeClass 與 A/B 之間。
屬性衝突:同一套邏輯,只是以 val 的形式出現
衝突通常用函式來討論,但屬性也會有同樣的行為,因為屬性本質上是 get()(有時還有 set())。
想像:
interface LeftLabel {
val label: String get() = "LEFT"
}
interface RightLabel {
val label: String get() = "RIGHT"
}
class BothLabels : LeftLabel, RightLabel {
override val label: String
get() = super<LeftLabel>.label + "+" + super<RightLabel>.label
}
fun main() {
val x = BothLabels()
println(x.label) // LEFT+RIGHT
}
super<LeftLabel>.label 本質上是呼叫某個特定介面的 getter。再次重申:衝突透過 override 以及明確選擇來源來解決。
4. 實務範例:用不同風格格式化支出
「人類可讀」與 CSV:兩個契約,一個衝突
把概念綁到一個實務的主控台應用(假設是支出追蹤器)。在課程進度走到這裡時,我們通常已經有資料模型(例如 data class Expense),並且偶爾會把它們輸出到主控台。隨著時間推進,幾乎不可避免會想把同一個實體用不同格式輸出:「人類可讀」以及「CSV」。
我們做兩個介面契約:一個負責「人類可讀」文字,另一個負責 CSV。並刻意製造衝突:兩者都提供 default 方法 formatTitle(...),但規則不同。
data class Expense(
val title: String,
val amount: Int
)
interface HumanFormat {
fun formatTitle(title: String): String =
title.trim().replaceFirstChar { it.uppercase() }
}
interface CsvFormat {
fun formatTitle(title: String): String =
"\"" + title.trim().replace("\"", "\"\"") + "\""
}
接著我們想要一個「兩種都會」的類別(例如之後會根據命令模式選擇格式):
class ExpenseTitleFormatter : HumanFormat, CsvFormat {
override fun formatTitle(title: String): String {
// 選擇「給人看」的規則
return super<HumanFormat>.formatTitle(title)
}
}
fun main() {
val f = ExpenseTitleFormatter()
println(f.formatTitle(" coffee ")) // Coffee
}
這個例子中最重要的一點:衝突不代表「你做錯了」。衝突代表「你有兩個合理的格式化規則,但在這個特定類別中必須做出選擇」。Kotlin 會強迫你把選擇固定在程式碼裡,而不是只存在腦中。
如果你反而需要 CSV 規則——把那一行改成 super<CsvFormat>.formatTitle(title) 即可。
組合行為:當 super 呼叫成為新規則
有時候,正確答案不是選其中一個實作,而是把它們組合起來並加上一條清楚的新規則。例如:保留人類可讀的標題,同時加註這是一個「匯出用字串」。
interface HumanFormat {
fun formatTitle(title: String): String =
title.trim().replaceFirstChar { it.uppercase() }
}
interface CsvFormat {
fun formatTitle(title: String): String =
"\"" + title.trim().replace("\"", "\"\"") + "\""
}
class MixedTitleFormatter : HumanFormat, CsvFormat {
override fun formatTitle(title: String): String {
val human = super<HumanFormat>.formatTitle(title)
val csv = super<CsvFormat>.formatTitle(title)
return "$human (csv=$csv)"
}
}
fun main() {
val f = MixedTitleFormatter()
println(f.formatTitle(" big \"sale\" ")) // Big "sale" (csv="big ""sale""")
}
請注意:我們刻意做了兩個中間 val。這比「寫成一行」稍長,但可讀性明顯更好——不管是對新手,還是對星期五晚上已經很累的資深開發者。
5. 速查表:何時需要 override,以及裡面該寫什麼
第一次遇到衝突時,大腦會想要一張簡單的速查表。我們做一個小表格:它無法取代理解,但能幫你不慌張。
| 情境 | 發生了什麼 | 該怎麼做 |
|---|---|---|
| 兩個介面都提供同一方法的 default | 兩個實作 → 產生歧義 | override + 透過 super<A>/super<B> 選擇或組合 |
| 一個介面是 default,另一個介面以抽象方式宣告 | Kotlin 要求明確化 | override + 要嘛寫自己的邏輯,要嘛用 super<WithDefault> |
| 基底類別與介面都實作了同一方法 | 來自不同超型的兩個實作 | override +(可選) super<Base> 和/或 super<Interface> |
| 帶 getter 的屬性(val)衝突 | 本質上是 getter 的衝突 | override val + 透過 super<...>.prop 選擇或組合 |
6. 如何閱讀別人的 override,並且不害怕
當你在專案裡看到像這樣的東西:
override fun foo() {
super<A>.foo()
super<B>.foo()
}
不要把它理解成「為了複雜而複雜」。這幾乎總是三種含義之一。
第一種含義:「兩個行為都重要,所以兩個都做」。這常見於 logging、通知、度量(metrics)收集、處理器鏈等。第二種含義:「我們選擇其中一個實作,但希望把選擇明確寫出來」。那麼方法內通常只有一個 super<...>。第三種含義:「我們不信任預設實作,完全自己寫一份」,那麼程式裡可能根本不會出現 super<...>。
一個好習慣:如果你看到介面衝突,問自己「這裡採用了什麼業務規則?」答案通常就寫在 override 的內容裡——也正是為了這個原因才寫出來的。
7. 介面多重實作時的常見錯誤
錯誤 #1:以為 Kotlin 會「選清單裡第一個介面」。
有些學生受其他語言習慣影響,會以為 class X : A, B 的意思是「如果有衝突,A 會贏,因為它在前面」。Kotlin 不這麼做。它刻意逼你透過 override 做決定,否則行為會太像魔法,而除錯會變成考古。
錯誤 #2:衝突時寫 super.ping(),然後困惑為什麼不行。
當實作來源不只一個時,不帶限定的 super 沒有唯一答案,編譯器也不允許你「用猜的」。這種情況必須寫成 super<A>.ping() 或 super<B>.ping()。這個語法不是裝飾,而是明確指定實作來源的方式。
錯誤 #3:沒有語意就把兩個實作「黏」在一起,得到奇怪結果。
技術上你幾乎總能寫 super<A>.foo(); super<B>.foo(),但在邏輯上可能很荒謬:例如兩個實作代表不同輸出格式或不同策略。如果你要組合行為,請讓它成為一條有意識的規則,且能從程式碼直接讀出(例如透過中間 val 與清楚的結果字串)。
錯誤 #4:因為「看起來只有一個實作」而沒注意到衝突。
「default + 抽象」常被理解成「不是有實作了嗎」。但 Kotlin 仍然要求 override,因為契約發生重疊。如果你不理解為什麼編譯器逼你覆寫方法,請檢查:可能第二個介面宣告了同名方法但沒有方法體。這不是 bug,而是可讀性防護。
錯誤 #5:建立太寬泛的介面,導致名稱一直衝突。
如果你經常在 print()、render()、format() 這類方法上撞到衝突,這可能是介面太通用、語意重疊的訊號。有時只要把方法改成更具體的名稱(renderCsvLine()、renderHumanLine()),程式碼會更好讀,衝突也會變少。
錯誤 #6:試圖用「萬用補丁」把衝突藏起來,而不是解決它。
有時會想「先能編譯再說」,於是寫了一個 override,回傳某個隨機值,並忽略兩個 default 實作。結果是:契約在形式上完成了,但行為變得不可預期。如果介面產生衝突,幾乎總表示你需要表達一條規則:「選 A」、「選 B」或「用某種方式組合」。
GO TO FULL VERSION