CodeGym /課程 /Kotlin SELF /Extension 函式:語法、receiver、可見性

Extension 函式:語法、receiver、可見性

Kotlin SELF
等級 38, 課堂 0
開放

1. 介紹

如果你曾經想過:「為什麼我第十次在寫同一段字串轉換?」那你其實已經差不多準備好理解 extensions 了。 Extension 函式是一種方式,讓你可以在不修改既有型別程式碼的前提下,替它加上方便的「看起來像方法」的操作。 這在型別是外部來源時(標準函式庫、第三方函式庫)特別有用,因為你實際上不可能(也不應該)去改它。

務必記住一個核心概念:extensions 不會新增真正的類別成員,它們只是讓你用方法語法去呼叫一般函式。

想像型別是一台辦公室裡的咖啡機。咖啡機是別人的,不能拆機改裝。但你可以在旁邊牆上貼一張「快速沖泡指南」,並告訴同事:「照這樣喝」。 咖啡機本身沒有改變,但使用起來更順手了。extension 就是那張指南,只是編譯器會假裝它像是被「內建」在咖啡機裡一樣。

為了不要停留在抽象層面,我們會以一個 CLI(主控台)風格的小程式為出發點:假設我們正在逐步做一個支出記錄。 我們會有像 add、list、total 這類命令,並且希望能乾淨而一致地處理使用者輸入。

2. Extension 函式的語法

在這一節我們會平穩地釐清 Kotlin 的 extension 函式長什麼樣,以及編譯器為什麼允許這種語法。 主要目標是:不要再把 fun String.xxx() 當成什麼超自然的東西。 這不是「把語言弄壞」,而是一種非常克制的語法糖:它會被轉換成一般函式呼叫,只是用更好讀的方式寫出來。

extension 函式的語法如下:

fun ReceiverType.functionName(params...): ReturnType {
    ...
}

其中 ReceiverType 是我們要「擴充」的型別。我們不改類別本身,但能得到這樣的呼叫形式: obj.functionName()。

最簡單的例子:把命令字串正規化——去掉前後空白、轉成小寫。

fun String.normalizeCommand(): String {
    return trim().lowercase()
}

fun main() {
    val raw = "   AdD   "
    println(raw.normalizeCommand()) // add
}

這裡的 normalizeCommand() 是一般函式;但因為寫成 fun String.normalizeCommand() 所以就可以像字串的方法那樣呼叫它。

從技術面(簡化來說)編譯器大概會把: raw.normalizeCommand() 轉成 normalizeCommand(raw)。 也就是說,這只是「把物件當作第一個參數傳進去」的更舒服寫法。

3. Receiver:extension 函式裡的 this 是誰

「receiver」這個詞聽起來像要架設網路伺服器,但其實很簡單。 Receiver就是呼叫 extension 函式的那個物件。 在函式本體裡,這個物件可以用 this 存取,就跟一般類別方法內的 this 一樣。 因此 extension 函式會「感覺」像方法:在裡面你可以直接寫 length、 trim()、 lowercase() 而不需要額外的限定。

Kotlin 文件強調:擴充「永遠是在 receiver 上被呼叫」,而且 receiver type 必須和被擴充的類別/介面型別相符。

看看一個例子:在 extension 函式裡我們顯式使用 this(雖然通常不需要):

fun String.isBlankAfterTrim(): Boolean {
    val prepared = this.trim()
    return prepared.isEmpty()
}

fun main() {
    println("   ".isBlankAfterTrim()) // true
    println("  hi ".isBlankAfterTrim()) // false
}

沒錯,這裡的 this 就是原始字串。它不是「特別的 this」、不是新物件、也不是拷貝;它就是同一個 receiver。

這帶出一個很實用的結論:extension 函式非常適合用來做「對物件的小操作」——你可以替它取個好名字,避免把邏輯散落在各處。

4. 在 CLI 中使用 extension:把 main 的雜訊拿掉

接下來會出現 extensions 最討喜的一個效果:它們讓腳本式(CLI)的程式碼更短、更好懂。 主控台程式常常有很多「樣板包裝」:讀一行、正規化、切成片段、檢查命令是否存在。 如果這些都直接堆在 main 裡,它很快就會變成托爾斯泰的長篇小說(我們想讀小說,不想拿來編譯)。

我們替字串做兩個小擴充:

  1. 命令正規化(trim() + lowercase()),
  2. 用空白把字串拆成「單字」,但不要空片段。
fun String.normalizeCommand(): String = trim().lowercase()

fun String.splitWords(): List<String> =
    trim().split(Regex("\\s+"))

fun main() {
    val input = "  ADD   coffee  250  "
    val words = input.normalizeCommand().splitWords()

    println(words) // [add, coffee, 250]
}

注意:邏輯變得可以由左到右閱讀。我們幾乎是在描述一條 pipeline:「正規化 → 切成單字」。 這就是 Kotlin 裡大家喜歡 extensions 的原因之一:程式碼讀起來像故事。Kotlin 也確實偏愛這種敘事感。

還有一點:Kotlin 標準庫本身就有大量 extension 函式(例如集合相關的),這也算是語言哲學的一部分——很多實用 API 就是透過擴充實作出來的。

5. 可見性:extension 函式能看到什麼

這裡有一段通常會打破新手期待的內容:「既然它像方法,那我就能拿到 private 欄位吧!」 不行。而且這其實是好事,否則我們很容易破壞外部類別的封裝。 extension 函式不是類別的一部分,所以它遵循一般可見性規則:只能看到「從外部」看得到的東西。

Kotlin 文件把它講得很直接:宣告在 receiver 類別外部的 extension,無法存取該類別的 private/protected 成員。

範例:不能讀取 receiver 的 private 欄位

class User(private val password: String) {
    fun passwordLength(): Int = password.length
}

fun User.isSecure(): Boolean {
    // password is not accessible here because it is private:
    // return password.length >= 8

    return passwordLength() >= 8
}

fun main() {
    val u = User("supersecret")
    println(u.isSecure()) // true
}

在這裡 extension 函式只能使用公開 API(passwordLength()),而不能直接去碰 password。這才是正確做法。

細節:檔案層級的 private 在同一個檔案內可見

另一個有用的細節:如果 extension 宣告在檔案的 top-level,它可以存取同一個檔案內的 private 函式/變數。 這不是「繞過私有」,而是一般規則:檔案層級的 private 表示「只在此檔案內可見」。

在我們的 CLI 情境下這很方便:你可以把正則或小工具藏成 private,再讓 extension 使用它們來提供漂亮的 API。

private val spaces = Regex("\\s+")

fun String.splitWords(): List<String> =
    trim().split(spaces)

fun main() {
    println("a   b    c".splitWords()) // [a, b, c]
}

這是一種很乾淨的方式:不把「服務性細節」暴露給外部,同時仍然能寫出整潔的擴充。

6. Kotlin 如何選擇 extension 函式

下面整理幾條在真實程式碼中最常決定 extensions 行為的規則:該放哪裡、如何用 import 引入、名稱衝突時誰會「贏」,以及為什麼 extensions 不會像 override 那樣提供多型。

extensions 放哪裡,以及如何用 import 引入

開始寫 extensions 之後,會出現一種新的混亂:「我有個檔案叫 Utils.kt,裡面塞了 400 個對所有東西的擴充」。 幾乎成了傳統。但我們會嘗試提前避免它。

概念很簡單:extensions 最好依語意放在一起,放到獨立的檔案/套件中,並在需要的地方引入。 Kotlin 對此支援得很自然:你把 extension 宣告在 top-level,然後像一般函式一樣 import 它。

迷你示意(概念圖):

// File: cli/TextExtensions.kt
package app.cli

fun String.normalizeCommand(): String = trim().lowercase()
// File: cli/Main.kt
package app.cli

import app.cli.normalizeCommand

fun main() {
    println("  ADD ".normalizeCommand()) // add
}

沒錯,import extension 的方式就跟一般函式一樣。這再次提醒我們:extension 不是「真正的類別方法」,它只是用更方便的語法呼叫函式。

Extension vs member function:同名時誰會贏

現在來到一個重要分岔:extension 函式以方法形式呼叫,但 Kotlin 也有真正的方法(member functions)。 如果類別已經有同名方法,會發生什麼?

Kotlin 的規則很明確:名稱與簽名都相同時,member function 優先,extension 會輸。

class Example {
    fun printType() {
        println("Member")
    }
}

fun Example.printType() {
    println("Extension")
}

fun main() {
    Example().printType() // Member
}

為什麼要這樣?因為不然 extensions 可能會在你不知情的情況下「攔截」類別行為,尤其是來自函式庫的類別。 Kotlin 選擇了可預測性:真正的方法永遠比「貼在咖啡機旁的貼紙」重要。

不過有個好消息:只要簽名不同,extension 可以多載(overload)。

class Example {
    fun printType() {
        println("Member")
    }
}

fun Example.printType(index: Int) {
    println("Extension #$index")
}

fun main() {
    Example().printType()      // Member
    Example().printType(2)     // Extension #2
}

對我們的 CLI 來說,這表示:當你擴充標準庫型別(String、List、Map)時,幾乎不會「破壞」它們的 API——你要嘛新增新名稱,要嘛謹慎地用不同簽名做多載(但別走火入魔)。

靜態選擇:為什麼這不是多型

這是今天的核心「陷阱」。我們知道在 OOP 中,override 會在執行期依物件的實際型別選擇。 新手很容易把同樣期待套到 extensions 上。但 Kotlin 的做法不同: extension 函式是以靜態方式解析,也就是在編譯期依變數型別決定,而不是依實際物件。

open class Animal
class Dog : Animal()

fun Animal.kind(): String = "animal"
fun Dog.kind(): String = "dog"

fun printKind(a: Animal) {
    println(a.kind())
}

fun main() {
    val a: Animal = Dog()
    val d: Dog = Dog()

    printKind(a)        // animal
    println(d.kind())   // dog
}

為什麼 printKind(a) 會印出 "animal"? 因為參數 a 的型別是 Animal。 即使裡面實際放的是 Dog,extension 仍然是依變數型別選擇,而不是依「內容」。

記憶法很簡單:extension 函式不會成為虛擬方法表的一部分(不參與 override 機制)。 它是外部的語法糖,所以不會啟動多型。

因此在實務上代表:不要試圖用 extensions 來「多型化」處理型別階層。 這應該交給一般方法與 override(或對 sealed 階層做 when,但那是另一個故事,今天不展開)。

Extension 函式不取代 override:用「formatter」示範

我們做一個例子,直接對比差異:override 依實際物件選擇;extension 依變數型別選擇。

假設我們有一個支出模型:

data class Expense(
    val title: String,
    val cents: Int
)

我們希望在主控台漂亮列印支出。先做兩個 formatter(用一般方法與 override),再加一個 extension 做對照。

open class ExpenseFormatter {
    open fun format(e: Expense): String = "${e.title}: ${e.cents} cents"
}

class PrettyExpenseFormatter : ExpenseFormatter() {
    override fun format(e: Expense): String = "• ${e.title} — ${e.cents}¢"
}

fun main() {
    val f: ExpenseFormatter = PrettyExpenseFormatter()
    val e = Expense("Coffee", 250)

    println(f.format(e)) // • Coffee — 250¢
}

這一段如預期運作:format() 被覆寫,呼叫時會選到 PrettyExpenseFormatter 的實作。

接著在 ExpenseFormatter 上加一個 extension(純示範,實際專案通常沒必要這麼做):

fun ExpenseFormatter.formatHeader(): String = "=== Expenses ==="

fun main() {
    val f: ExpenseFormatter = PrettyExpenseFormatter()
    println(f.formatHeader()) // === Expenses ===
}

這能運作,但要理解:formatHeader() 無法像一般方法那樣透過繼承被「覆寫」,因為它不是類別的方法。 它就是外部函式,只是用方法語法呼叫。

結論:如果你需要依型別替換行為——用 override。 如果你想從外部加上一個方便的操作——用 extension。

迷你對照表:方法 vs extension

有時把兩個概念並排放著就很有幫助,讓大腦停止混淆。 兩者都有 receiver,呼叫長得也像,但在選擇規則與存取權限上完全不同。

特性 一般類別方法(member function) Extension 函式
宣告位置 類別內部 外部(通常 top-level)
呼叫方式
obj.f()
obj.f()
實作選擇 可透過 override 動態選擇 靜態:依變數型別
存取 receiver 的 private 成員 可以(它就是類別的一部分) 不行(若 extension 宣告在類別外)
同名衝突時 它才是事實來源 同簽名時會輸給 member

這張表不用背。只要記住兩個「錨點」: extension 是靜態解析;而且若宣告在外部,就看不到 receiver 的 private 成員。

7. 使用 extension 函式時的常見錯誤

錯誤 1:期待像 override 一樣有多型。
很常見的陷阱:寫了 fun Dog.kind(),並以為透過 Animal 呼叫仍會得到 "dog"。 但 extension 是依變數的 declared type(靜態)決定,而不是依實際物件。

錯誤 2:嘗試存取 receiver 類別的 private/protected 成員。
若 extension 宣告在類別外部,它不會變成「自己人」:private 成員仍然是 private。 若你真的需要存取,通常代表類別應該提供公開方法/屬性(或你用錯地方解題了)。

錯誤 3:把 extensions 變成 Utils.kt 的垃圾桶。
當擴充變多後,很容易想把它們「先丟到某個地方」。 一個月後就變成考古現場:「normalize() 到底宣告在哪?為什麼有三個?」 更好的方式是依語意就近放置,並在真正使用的地方 import。

錯誤 4:給 extensions 取太通用的名字。
像 process()、handle()、doStuff() 這種名字,不管是方法還是 extension 都很糟。 但 extension 還有額外問題:它讀起來像「型別內建的能力」。 如果字串突然多了一個 process(),未來的讀者就得去翻它到底做什麼。 好的名稱應該描述結果:normalizeCommand()、splitWords()、toMoneyLabel()。

錯誤 5:忘記 member 方法的優先權。
有時開發者寫了同名 extension,期待改變類別行為,結果疑惑:「為什麼沒有被呼叫?」 若類別已經有同簽名的 member 方法,它會勝出。

1
任務
Kotlin SELF, 等級 38, 課堂 0
上鎖
機器人指令
機器人指令
1
任務
Kotlin SELF, 等級 38, 課堂 0
上鎖
空白檢查
空白檢查
1
任務
Kotlin SELF, 等級 38, 課堂 0
上鎖
密碼與存取
密碼與存取
1
任務
Kotlin SELF, 等級 38, 課堂 0
上鎖
方法優先權
方法優先權
留言
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION