1. JVM 上的 Type erasure
當你剛開始寫泛型函式時,常會冒出一個很「人性」的念頭:「我現在就寫 fun <T> ..., 然後在裡面檢查 x is T,一切就很完美。」 這就像你有一個盒子,上面寫著「裡面是餅乾」,你以為隨時都能打開確認裡面真的有餅乾,而不是襪子。
但 Kotlin(更精確地說,JVM 上的 Kotlin)會突然告訴你:「不行,不能這樣做。」這不是編譯器故意刁難,而是在防止你產生錯誤的安全感。 如果允許這種檢查,它常常會「看起來像是」能運作,但之後會在最奇怪的地方以很不舒服的方式壞掉。
原因在於——型別抹除(type erasure)。
什麼是 type erasure,究竟「抹除」了什麼
型別抹除是 JVM 世界的規則:型別參數(也就是 <...>裡的內容)在多數情況下只存在於編譯期, 而在執行期程式只會以「泛化後的形式」來運作。比如: List<Int> 與 List<String> 在 runtime 看起來都只是 List(可以理解成「某種元素的清單」)。 Kotlin 會誠實地提醒你:generic 型別的實例不會保存其實際型別引數的資訊——尖括號的資訊被抹掉了。
為什麼要這樣設計?歷史上 JVM 的設計目標是讓 Java generics 不破壞與舊程式碼的相容性。 因此,泛型主要是編譯器做檢查與提供保證,而不是在物件裡藏著「執行期的魔法標籤」。
用更直觀的方式可以這樣想:
flowchart LR
A["Source: List⟨Int⟩, List⟨String⟩"] --> B["Compiler: type safety checked"]
B --> C["Bytecode/JVM: at runtime it's just List"]
C --> D["Cannot distinguish ⟨Int⟩ vs ⟨String⟩ anymore"]
為什麼禁止 is List<Int> 與 is T,以及可以用什麼取代
現在就比較容易理解,為什麼 Kotlin 會禁止像 x is List<Int> 這種檢查: 在 runtime 你無法可靠地分辨「Int 的清單」與「String 的清單」,因為型別引數已經被抹除了。 Kotlin 會直接說:由於 type erasure,沒有通用的方法可以檢查某個 generic 實例是用哪些型別引數建立的,因此 is 檢查像是 ints is List<Int> 或 list is T (其中 T 是型別參數)都被禁止。
不過仍有一個安全的折衷:檢查 star-projection,例如 is List<*>。 它表示「這是一個裝著某種元素的清單,但元素型別未知」。這種檢查很誠實:它不對元素做任何承諾,所以編譯器允許。
範例——「可以做什麼」:
fun main() {
val x: Any = listOf(1, 2, 3)
if (x is List<*>) {
println("這是一個大小為 ${x.size} 的清單") // 這是一個大小為 3 的清單
println("第一個元素:${x[0]}") // 第一個元素:1
}
}
請注意:在 x is List<*> 之後,元素會被視為 Any?。 這很合理:既然不知道元素型別,最安全的做法就是把它當成「某個東西」。
沒有 <...> 的「raw」型別:if (list is ArrayList) 是什麼意思
還有一個很實用的技巧,一開始看起來像作弊:有時可以只檢查外層類別, 不碰型別引數。 例如 ArrayList 是清單的一個具體實作,檢查「是不是 ArrayList」是可行的,即使你不知道裡面是 <String> 還是 <Int>。 Kotlin 允許這種檢查,但有個重要細節:你必須省略尖括號。
範例:
fun main() {
val names: MutableList<String> = arrayListOf("Ann", "Bob")
if (names is ArrayList) {
println("是的,這是 ArrayList。size=${names.size}") // 是的,這是 ArrayList。size=2
}
}
這裡 Kotlin 可以 smart cast 成 ArrayList<String> (因為在編譯期它本來就知道 names 是 MutableList<String>)。 但 runtime 的檢查本身只針對沒有 <...> 的 raw ArrayList。
3. inline 與 reified:如何合法地做 is T、as? T 與 T::class
起點:「如果我真的需要知道型別怎麼辦?」
到這裡會出現一個很工程化的問題:「如果型別被抹除了,那要怎麼寫依賴型別的通用工具?」 基本上有兩種做法。第一種是顯式傳入「型別 token」(在 Java 常是 Class<T>,在 Kotlin 是 KClass<T>)。 第二種是利用 Kotlin 提供的能力:inline + reified。
這堂課我們專注在第二種方式,因為它看起來像魔法,但其實是編譯器把程式碼「安全地展開」到呼叫點。 Kotlin 強調:一般的 generic 函式不能用型別參數來做 is 檢查或轉型; 例外是——帶有 reified 型別參數的 inline 函式。
inline:什麼叫「把程式碼貼到呼叫點」
inline 的字面意思是:「編譯器會把函式本體直接插入到呼叫它的地方」。 這對高階函式(帶 lambda)特別有用,可以減少額外物件;但我們現在更在意的是: 當函式本體被插入呼叫點時,具體型別 T 會在那個位置對編譯器變得可知。
不用真的去看 bytecode,但可以用這個簡圖把概念放在腦中:
flowchart TD
A["Call: foo<String>(x)"] --> B["Compiler sees T=String"]
B --> C["Inlines foo body right here"]
C --> D["Inside the body you can write x is String"]
reified:如何讓 T 在函式內「可見」
reified 是型別參數的修飾子,而且只能用在 inline fun 上。 它的意思是:「型別 T 可以在這個函式內用於 runtime 檢查」,就好像 T 是一般的 class 一樣。 Kotlin 直接展示其效果:有了 reified,你可以寫 x is T 以及 x as? T, 不需要反射,也不需要手動傳 Class<T>。
請記住一個短規則:reified 一定要搭配 inline。
為什麼「一般」generic 函式無法編譯
下面這段「很想寫」的想法是不會通過編譯的(這很正常):
// Idea (does not compile):
// fun <T> isOfType(x: Any): Boolean = x is T
編譯器禁止它,因為 T 在 runtime 是「被抹除」的。
同樣的想法,但寫對:inline + reified
inline fun <reified T> isOfType(x: Any): Boolean = x is T
fun main() {
val a: Any = "hello"
println(isOfType<String>(a)) // true
println(isOfType<Int>(a)) // false
}
這裡有一個很重要、但完全不神怪的動作:呼叫 isOfType<String>(a) 時,編譯器會把檢查展開成 a is String。 而呼叫 isOfType<Int>(a) 時,則展開成 a is Int。
as? T:在泛型工具裡做安全轉型
is 檢查適合你只需要 Boolean 的情境。 但在實務程式碼裡更常見的是「試著轉型;如果不行,就平靜地繼續」。 這時最適合的是安全轉型 as?:轉不了就回傳 null。
來做一個通用函式 castOrNull:
inline fun <reified T> castOrNull(x: Any): T? = x as? T
fun main() {
val x: Any = 42
val s: String? = castOrNull<String>(x)
val n: Int? = castOrNull<Int>(x)
println("s=$s") // s=null
println("n=$n") // n=42
}
接著用 Elvis 運算子 ?:(你在 null-safety 裡已經用過很多次)加上人類可讀的備援行為:
inline fun <reified T> castOrDefault(x: Any, default: T): T {
return (x as? T) ?: default
}
fun main() {
val x: Any = "text"
val num = castOrDefault<Int>(x, default = -1)
println(num) // -1
}
重點在於:這裡我們不會用例外把程式打爆,而是選擇備案。
T::class:用於訊息、log 與小型檢查的類別「token」
有時你不是想轉型,而是想清楚說明你期待的是什麼。 這時 T::class 很有用:它回傳 KClass 物件,也就是「把類別描述當成一個值」。 Kotlin 表示:在 reified 的情況下,你可以存取 T::class。
做一個小函式,印出期待型別的名稱:
inline fun <reified T> expectedTypeName(): String {
return T::class.simpleName ?: "<unknown>"
}
fun main() {
println(expectedTypeName<String>()) // String
println(expectedTypeName<List<*>>()) // List
}
再來做一個更實用的版本:「我要求這個型別,否則就丟出帶清楚訊息的錯誤」。 這裡我們用 error(...),它會回傳 Nothing(你在討論 Nothing 與「函式不返回」時應該看過)。
inline fun <reified T> requireType(x: Any): T {
return (x as? T) ?: error("Expected ${T::class}, got ${x::class}")
}
fun main() {
val x: Any = "hi"
val s: String = requireType(x)
println(s) // hi
}
這種 helper 對應用程式內部的檢查非常方便:當你對邏輯很有把握,但又希望一旦出錯時,訊息不是「某處的 ClassCastException」, 而是「期待什麼、實際拿到什麼」。
reified 的限制:為什麼 List<String> 仍然很滑
這時可能會冒出一個危險想法:「既然 reified 讓 T 可見,那我就能做 x is List<String> 吧。」 很可惜,不行:generic 型別裡的型別引數也會被抹除。 Kotlin 會明確提醒:即使有 reified,限制仍在——若 arg 本身是 generic 型別,它的型別引數依然被抹除。
這表示「它是一個 String 清單」這種檢查仍然很麻煩。但你可以做一個誠實、符合邏輯的兩步檢查: 先確認它是 List<*>,再逐一檢查元素。
fun main() {
val x: Any = listOf(1, 2, 3)
if (x is List<*>) {
val allStrings = x.all { it is String }
println(allStrings) // false
}
}
是的,這沒有 x is List<String> 那麼「漂亮」,但它確實能運作,而且不會對你撒謊。
4. 實作:「事件日誌」與依型別挑選元素
想像一下:在我們課程中逐步擴充的教學用主控台程式裡,我們開始維護一個簡單的事件日誌。 即使是小程式也常這麼做:不是為了架構,而是為了除錯。 問題在於事件可能是不同型別;最直覺的做法就是把它們塞進 List<Any>。
這時 reified 變得非常實用:你可以寫一個工具「從日誌中拿出所有某個特定型別的事件」—— 不用手寫一堆 as,也不用塞滿 if。
先定義兩種事件型別:
data class ExpenseAdded(val amount: Double)
data class NoteAdded(val text: String)
接著寫一個函式:「從 Any 清單中挑出所有 T 型別元素」:
inline fun <reified T> pickAllOfType(items: List<Any>): List<T> {
val result = mutableListOf<T>()
for (item in items) {
if (item is T) result.add(item)
}
return result
}
使用方式:
fun main() {
val log: List<Any> = listOf(
ExpenseAdded(10.0),
NoteAdded("coffee"),
ExpenseAdded(25.5),
)
val expenses = pickAllOfType<ExpenseAdded>(log)
println(expenses) // [ExpenseAdded(amount=10.0), ExpenseAdded(amount=25.5)]
}
這是一個很典型的例子:reified 真的能把程式碼裡的「雜訊」移掉—— 你不需要每次手寫搭配 as? 的迴圈,也不容易不小心用到不安全的 as。
5. 使用 type erasure 與 inline/reified 時的常見錯誤
錯誤 1:以為 fun <T> 在沒有 reified 的情況下也能做 x is T。
這是很常見的邏輯陷阱:你會覺得既然程式碼裡寫了 T,那它在執行期也「存在」。 但在 JVM 上它主要是給編譯器用的;到 runtime 會被抹除,所以 Kotlin 才禁止這種檢查。 解法只有一個:要嘛顯式傳「型別 token」,要嘛用 inline fun <reified T>——並記得 reified 不可能單獨存在,必須搭配 inline。
錯誤 2:嘗試檢查巢狀型別引數,例如 x is List<String> 並以為它可靠。
就算你很想用一個表達式證明「這是 String 清單」,runtime 也不知道,因為 String 在 List<...> 裡被抹除了。 正確風格是:先用 is List<*> 檢查外層型別, 再用程式邏輯檢查元素。 Kotlin 也會特別提醒:就算你使用了 reified,generic 引數仍然會被抹除。
錯誤 3:在泛型工具裡使用 as 而不是 as?,導致「不知從哪裡冒出來」的崩潰。
as 的意思是「相信我,我知道型別」,一旦錯了就會丟例外。 在處理 Any 或「性質未知」資料的工具函式中,幾乎總是更合理先用 as? 回傳 T?,再決定要用 ?:(給預設值)或用清楚的訊息主動報錯。
錯誤 4:把 inline 當成免費優化,什麼都先 inline 「以防萬一」。
inline 是會改變程式碼生成方式的工具(把函式本體複製到呼叫點)。 它在需要 reified,或在 lambda 真的有收益時很有用,但它不是「萬能加速器」。 有時 inline 會讓 bytecode 變大,並讓除錯更麻煩。 這堂課我們用 inline 不是為了速度,而是為了讓 T 能用於檢查。
GO TO FULL VERSION