CodeGym /課程 /Kotlin SELF /sealed interface — 封閉的變體集合

sealed interface — 封閉的變體集合

Kotlin SELF
等級 37, 課堂 3
開放

1. 為什麼最好不要用字串與旗標來存變體

當程式剛開始寫的時候,常常會覺得最簡單的做法是「隨便存一下狀態」:用字串 "ok"/"error",用數字 0/1,用兩個旗標 isOk 和 hasError,甚至有時候再加上 null「以防萬一」。在小型程式碼上這確實能跑——直到第一個「糟了,那如果……」出現為止。

問題在於:這種做法無法讓編譯器幫你。字串很容易打錯、旗標可能被設成互相矛盾的狀態,而 null 可能突然出現在你完全沒預期的地方。最後你等於是在自己玩一個任務:「猜猜有哪些值是可能的」。

想像一個迷你例子:在主控台應用程式中回傳指令結果:

fun render(status: String, message: String): String {
    return if (status == "ok") "OK: $message" else "ERROR: $message"
}

這裡會冒出的問題(不是哲學,而是很實際的問題):
如果 status = "OK" 呢?如果是 "success" 呢?如果是空字串呢?如果是帶空白的 "ok " 呢?誰能保證不會有其他變體?

而 Kotlin 在這裡提供了一個工具,等於是在說:「我們把變體列清楚,讓編譯器能夠約束你。」 這就是 sealed interface。

2. sealed interface 帶來什麼好處

sealed 這個詞可以理解為「封印/封閉」。想法很簡單:我們宣告一個介面(契約),同時告訴編譯器: 實作的數量是有限的,Kotlin 在分析程式碼時可以把它們納入考量。

最令人愉快的結果就是 when。我們已經知道 when 可以是 statement(只執行分支),也可以是 expression(回傳值)。 而如果 when 用作表達式,Kotlin 會要求覆蓋所有情況——否則它就不是表達式,而是「碰運氣」。

也就是說,sealed interface 同時給了我們兩件事:

  • 第一:型別安全(「變體」變成了型別),
  • 第二:編譯器支援(「你忘了處理某個變體——我就不讓你建置成功」)。

建議你在腦中保留一個畫面:sealed interface 是「一個變體家族」,而具體的實作則是「這個家族的小孩」。 一旦新增了新的「小孩」,編譯器就會逼你更新所有透過 when 來解析這個家族的地方。

3. sealed interface Command:指令模型

我們繼續擴充教學用的主控台應用程式(姑且叫它 ExpenseTracker)。之前我們已經用過清單/集合、字串、 when、類別與 data class。現在我們希望使用者輸入指令:add、list、help、exit。

如果把指令用字串存起來——我們又回到「如果字串很奇怪怎麼辦」的問題。所以我們把 Command 做成 sealed interface,並列出所有變體。


sealed interface Command {

    data class Add(val amount: Int, val category: String) : Command

    class List : Command
    class Help : Command
    class Exit : Command

    data class Unknown(val raw: String) : Command
}

請注意幾個細節。

第一,Add 是 data class,因為這個指令帶資料:金額與分類。

第二,List/Help/Exit 我們做成沒有欄位的一般類別。 是的,它們會有不同的實例。這很正常:指令的語意由型別決定,而不是由你建立了多少個物件決定。

第三,Unknown 是非常實用的變體。初學者常常想做「封閉集合」卻忘了使用者輸入可以是任何東西。 結果不是程式崩潰,就是寫了 else 而失去 sealed 的意義。Unknown 是誠實的方式:表示「我們什麼都處理了,包含垃圾輸入」。

4. 把輸入解析成 Command

請把解析(parsing)當作一種契約:「輸入是一個字串,輸出是 Command 的其中一個變體」。 不是 String?,不是 Pair<Boolean, String>,而是一個正常的型別。

基礎解析器

fun parseCommand(raw: String): Command {
    val parts = raw.trim().split(" ")
    val name = parts.firstOrNull()?.lowercase() ?: return Command.Unknown(raw)

    return when (name) {
        "add" -> Command.Unknown(raw) // 之後再解析參數
        "list" -> Command.List()
        "help" -> Command.Help()
        "exit" -> Command.Exit()
        else -> Command.Unknown(raw)
    }
}

這裡我們先刻意「沒做完」 add:把參數解析出來當然可以,但我們現在更重要的是看見整體原則——指令變成了型別。

注意:這裡的 when 是表達式(我們回傳結果),所以每個分支都必須回傳某個東西。 但目前 when 是對字串做判斷,而字串的可能性是無限的,所以 else 在這裡是合理且誠實的。

為 add 解析參數

為了讓例子更接近真實,我們來改進 add 的解析。假設指令長這樣:

add 120 food

也就是 parts[1] 是金額,parts[2] 是分類。 安全的解析方式是用 toIntOrNull() 搭配檢查。

fun parseCommand(raw: String): Command {
    val parts = raw.trim().split(" ").filter { it.isNotBlank() }
    val name = parts.firstOrNull()?.lowercase() ?: return Command.Unknown(raw)

    return when (name) {
        "add" -> {
            val amount = parts.getOrNull(1)?.toIntOrNull()
            val category = parts.getOrNull(2)
            if (amount != null && category != null) Command.Add(amount, category)
            else Command.Unknown(raw)
        }
        "list" -> Command.List()
        "help" -> Command.Help()
        "exit" -> Command.Exit()
        else -> Command.Unknown(raw)
    }
}

是的,我們仍然回傳 Unknown——這不是「很差的指令」,而是解析結果的一種正常變體。 我們不假裝輸入永遠完美。

5. 對指令做完整的 when(exhaustive when)

最好玩的部分從處理指令開始。我們想寫出「依照指令型別決定行為」的邏輯。 這正是 when 對 sealed 型別可以做到完整覆蓋的情境。

先加上一個簡單的支出模型(你的專案裡可能更豐富,但我們現在重點是概念):

data class Expense(val amount: Int, val category: String)

接著做一個指令處理器:

fun handleCommand(cmd: Command, expenses: MutableList<Expense>): String =
    when (cmd) {
        is Command.Add -> {
            expenses.add(Expense(cmd.amount, cmd.category))
            "Added: ${cmd.amount} in category ${cmd.category}"
        }
        is Command.List -> "Expenses: ${expenses.size}"
        is Command.Help -> "Commands: add/list/help/exit"
        is Command.Exit -> "Exiting..."
        is Command.Unknown -> "Unknown command: ${cmd.raw}"
    }

這裡有個重要點:不需要 else。為什麼?因為 Command 是 sealed interface,編譯器知道所有變體。 如果你忘了處理(例如)Command.Help,Kotlin 會在看到 when 以表達式使用、但沒有覆蓋所有分支時開始報錯。

還有一個額外好處:在 is Command.Add 的分支中會觸發 smart cast, 因此 cmd 會被視為 Command.Add,你可以直接使用 cmd.amount 與 cmd.category,不需要手動轉型。

6. sealed interface CommandResult:成功與錯誤

當你在寫指令時,勢必會遇到一個問題:「指令是否成功執行?」。 新手常見做法是:

  • 回傳 Boolean,另外再印文字,
  • 回傳一個字串,有時候是 "ERROR: ...",
  • 發生錯誤就回傳 null(然後在不該出錯的地方遇到 NullPointerException)。

更清楚的方式是把結果描述成封閉的變體集合:成功或錯誤。這幾乎就是 sealed interface 的教科書案例。

sealed interface CommandResult {
    val message: String

    data class Ok(override val message: String) : CommandResult
    data class Error(override val message: String) : CommandResult
}

現在 handleCommand 就可以回傳的不是字串,而是 CommandResult:

fun handleCommand(cmd: Command, expenses: MutableList<Expense>): CommandResult =
    when (cmd) {
        is Command.Add -> {
            expenses.add(Expense(cmd.amount, cmd.category))
            CommandResult.Ok("Added: ${cmd.amount} in category ${cmd.category}")
        }
        is Command.List -> CommandResult.Ok("Expenses: ${expenses.size}")
        is Command.Help -> CommandResult.Ok("Commands: add/list/help/exit")
        is Command.Exit -> CommandResult.Ok("Exiting...")
        is Command.Unknown -> CommandResult.Error("Unknown command: ${cmd.raw}")
    }

再另外做一個結果渲染:

fun renderResult(r: CommandResult): String =
    when (r) {
        is CommandResult.Ok -> "OK: ${r.message}"
        is CommandResult.Error -> "ERROR: ${r.message}"
    }

再一次:else 不需要,因為變體集合是封閉的。 最後程式碼讀起來更像流程劇本,而不是「一堆字串式的土法煉鋼」。

7. main 的迷你迴圈

現在把所有東西串起來做成迷你應用程式。它仍然很簡單,但結構已經很舒服了: 輸入 → 解析成 Command → 執行 → 印出結果。 而且你不需要在任何地方猜測「可能有哪些值」。

fun main() {
    val expenses = mutableListOf<Expense>()

    while (true) {
        print("> ")
        val cmd = parseCommand(readln())

        val result = handleCommand(cmd, expenses)
        println(renderResult(result))

        if (cmd is Command.Exit) break
    }
}

對話範例(大概會長這樣):

> add 120 food
OK: Added: 120 in category food
> list
OK: Expenses: 1
> abracadabra
ERROR: Unknown command: abracadabra
> exit
OK: Exiting...

注意:有多少「隨機約定」被消除掉了。我們有兩個封閉集合:Command 與 CommandResult。 而在這兩種情況中,編譯器都成了你的隊友:你一新增變體——它就會強迫你在 when 裡處理它。

8. 有用的細節

該選 enum、sealed class,還是 sealed interface

當你開始使用 sealed interface,常見問題是: 「既然有 sealed class 或 enum,那為什麼還需要它?」。 這是很正常的問題:工具很像,但用途略有不同。

下面是一個簡單的「感覺表」,不深入到位元碼層級:

工具 何時方便 核心想法
enum class
變體是固定的,且不帶資料(或所有變體都有相同欄位) 「列舉值」
sealed class
變體固定,有時希望共用狀態/建構子 「帶有基礎實作的變體家族」
sealed interface
變體固定,但更重視契約而不是「基底」;另外也能同時實作其他介面 「封閉契約:已知的實作」

今天我們的 Command 本質上就是契約:「這是一個指令,它有若干明確變體」。 我們不需要共用建構子或基底欄位,所以 sealed interface 很自然。

when 的 guard conditions

有時候光靠「變體」還不夠:你可能想說「這是 Add,但金額必須是正數」。 Kotlin 在 when 裡有 guard conditions 的語法:分支不只可以是 is Type,還可以是 is Type if ...。

我們小心地把它套用到指令上。比如:把負數金額視為錯誤:

fun handleCommand(cmd: Command, expenses: MutableList<Expense>): CommandResult =
    when (cmd) {
        is Command.Add if cmd.amount <= 0 ->
            CommandResult.Error("Amount must be positive")

        is Command.Add -> {
            expenses.add(Expense(cmd.amount, cmd.category))
            CommandResult.Ok("Added: ${cmd.amount} in category ${cmd.category}")
        }

        is Command.List -> CommandResult.Ok("Expenses: ${expenses.size}")
        is Command.Help -> CommandResult.Ok("Commands: add/list/help/exit")
        is Command.Exit -> CommandResult.Ok("Exiting...")
        is Command.Unknown -> CommandResult.Error("Unknown command: ${cmd.raw}")
    }

guard conditions 的意義在於:你不必把邏輯拆成「when 依型別」+「分支裡再加 if」。 讀分支時就像讀一句話:「如果這是 Add 而且金額無效——那就是錯誤」。

9. 使用 sealed interface 時的常見錯誤

錯誤 #1:宣告 sealed,卻還是在關鍵的 when 裡寫「空的」else。
有些人習慣性會加上 else -> ...,即便變體集合是封閉的。 結果你就失去最重要的好處:以後新增新變體時,編譯器不會逼你處理它,因為「反正你有 else」。 這會讓 sealed 變成只是裝飾貼紙。

錯誤 #2:試圖用例外或 null 取代 Unknown,然後再收拾後果。
Unknown 不是設計的弱點,而是誠實面對現實:使用者輸入可以是任何東西。 如果你回傳 null,你就迫使整個程式都走向「以 nullable 為中心」的寫法。 如果你丟例外,你就把一般的使用者錯誤變成「事故」。 Unknown 讓狀況仍在可控範圍內。

錯誤 #3:在同一個 sealed 契約中混入不同的職責。
有些人會想把所有東西都塞進 sealed interface:指令、結果、事件,還有「順便再塞個東西」。 最後 when 變得難以閱讀:分支不再描述同一件事。 如果你覺得變體不再像「同一家族」,那就該把契約拆開了。

錯誤 #4:給變體取不直覺的名字(Good、Bad、X1、X2)。
sealed 的核心力量是可讀性與流程感。 當你寫 when (result) { is Ok -> ... is Error -> ... },讀起來就像在講故事。 如果命名太抽象,你的 when 就會變成謎題,而不是行為劇本。

錯誤 #5:在變體內部建立「自相矛盾」的模型,等於回到旗標問題。
就算用了 sealed,你仍然可能踩雷:例如在 data class Error(...) 裡放 message: String? 然後開始傳 null;或在 Ok 裡加一個 isOk: Boolean。 變體本身就已經表達了語意。不要再用旗標去重新編碼語意,否則模型會開始自相矛盾。

錯誤 #6:忘記 when 有 statement 與 expression 之分,導致期待混亂。
當 when 用作表達式時,Kotlin 會要求完整覆蓋所有情況。 初學者有時會疑惑:「為什麼編譯器在罵我?我明明都處理了……好像吧。」 一個實用習慣是:立刻看出你是在回傳值(val x = when (...))還是只是執行分支。 這會直接影響是否必須做到 exhaustive。

1
任務
Kotlin SELF, 等級 37, 課堂 3
上鎖
交通號誌提示
交通號誌提示
1
任務
Kotlin SELF, 等級 37, 課堂 3
上鎖
登入畫面
登入畫面
1
任務
Kotlin SELF, 等級 37, 課堂 3
上鎖
計算器命令
計算器命令
1
任務
Kotlin SELF, 等級 37, 課堂 3
上鎖
鎖的邏輯
鎖的邏輯
留言
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION