1. 前言
如果把生活簡化到「編譯器別太聰明」的程度,那當然會想直接寫 as 然後繼續過日子。 但 Kotlin 正是在試著救我們,避免出現「程式能編譯,卻在執行期某個離案發地點很遠的地方崩潰」的情況——而且還一副「我其實早就警告過你」的表情。
問題在於:有些容器天生就是「既讀又寫」。 對這種容器,你無法在類別宣告上老實地標成 out 或 in——否則它會失去一半的意義。 經典例子就是 Array<T>:既能用索引讀取,也能用索引寫入。 Kotlin 會直接用這個例子來說明:為什麼 Array 是不變的,以及如何用投影來解決。
Type projections 是一種折衷:我們不改 Array 這個類別,但在某個特定函式中「縮減」它的能力,讓編譯器可以保證型別安全。
2. 為什麼 Array<T> 是不變的
對陣列很容易掉進「反正是容器,就應該像 List 一樣」的陷阱。 但 Kotlin 的 List 是「只讀」介面,而 Array 是真正的「可用索引存取的盒子」:既能看,也能塞回去東西。
簡化來看,可以把 Array<T> 想成有這些操作:
operator fun get(index: Int): T
operator fun set(index: Int, value: T)
正因如此,Kotlin 不能把 Array 做成協變(像 List 那樣),否則就可能寫入錯誤的型別。 這也是為什麼單純的「從 Array<Int> copy 到 Array<Any>」在沒有額外技巧時無法編譯。
來親身感受一下。
fun copyNaive(from: Array<Any>, to: Array<Any>) {
for (i in from.indices) {
to[i] = from[i]
}
}
fun main() {
val ints: Array<Int> = arrayOf(1, 2, 3)
val any: Array<Any> = arrayOf("x", "y", "z")
// copyNaive(ints, any) // 無法編譯:Array<Int> 不是 Array<Any>
}
而這其實是好事:如果編譯器允許了,理論上在 copyNaive 裡就可能做出 from[0] = "oops" (也就是把 String 寫進 Int 的陣列)。 Kotlin 會事先阻擋這類錯誤。
3. Array 的投影:out 與 in
投影 Array<out X>:來源陣列
當你在函式參數寫下 Array<out Any>,你是在告訴編譯器: 「我拿到的是一個保證包含至少是 Any 的元素的陣列,但我承諾:我不會往裡面寫入。」 也就是說,這個陣列透過此引用變成 producer 物件——值的來源。
重點在於其背後哲學: Array<out Any> 不是一種新的陣列型別。 它仍是同一個陣列,但透過這個引用你無法使用危險的寫入操作(或在型別上變得不可能)。
Kotlin 在官方對 type projections 的說明中,正是使用「從一個我們不應修改的陣列中複製」這個想法。
寫一個安全的 copyToAny
做一個謹慎的 copy,其中 from 只能讀取。
fun copyToAny(from: Array<out Any>, to: Array<Any>) {
for (i in from.indices) {
to[i] = from[i]
}
}
fun main() {
val ints: Array<Int> = arrayOf(1, 2, 3)
val dest: Array<Any> = Array(3) { "?" }
copyToAny(ints, dest)
println(dest.joinToString()) // 1, 2, 3
}
注意這個看起來不像魔法的「魔法」: 我們把 Array<Int> 傳到了需要 Array<out Any> 的地方。 這之所以可行,是因為 Kotlin 現在能確信:我們不會對 from 做寫入, 因此也不可能用 String 的寫入去「弄壞」Int 的陣列。 這正是 use-site variance / type projection 的意義。
在 Array<out X> 中哪些事情會被禁止
如果你很想測試編譯器的耐心,可以試試:
fun breakIt(from: Array<out Any>) {
// from[0] = "boom" // 無法編譯
}
這不是「Kotlin 在刁難」。Kotlin 只是在老實履行契約: out 投影代表「可以讀,但不能寫」。
投影 Array<in X>:接收陣列
接著看鏡像情境。有時候我們需要陣列不是當來源,而是當接收端: 我們想把它填滿。此時我們在乎的是 set,而讀取是次要的。
Array<in String> 可以讀成:「某種 String 的父型別的陣列,我可以安全地把字串放進去。」
用字串填滿陣列:fillWithOk
fun fillWithOk(dest: Array<in String>) {
for (i in dest.indices) {
dest[i] = "ok"
}
}
fun main() {
val anyArray: Array<Any> = Array(3) { 0 }
fillWithOk(anyArray)
println(anyArray.joinToString()) // ok, ok, ok
}
為什麼安全?因為 Array<Any> 的確能存放 String: 字串就是 Any。
為什麼從 Array<in X> 讀取會變得更「貧乏」
這裡有個很多人會覺得惱人的點(然後會習慣,接著開始對其他事情惱人)。
如果我們有 Array<in String>, 那就不能把它當成能讀出 String:因為它實際上可能是 Array<Any>,裡面可能不只有字串。 所以安全的讀取通常只能得到 Any?。
fun showFirst(dest: Array<in String>) {
val x: Any? = dest[0]
println("first = $x") // first = ...
}
fun main() {
val anyArray: Array<Any> = arrayOf(10, 20, 30)
showFirst(anyArray) // first = 10
}
再強調一次:這不是刁難,而是保證。in 的契約說: 「我可以寫入 String」,但不承諾裡面原本放了什麼、也不承諾那些值的型別。
4. MutableList 的投影:out 與 in
陣列搞懂了,接著來看更貼近實務的:MutableList。 它在語意上「既讀又寫」,因此也不能「直接」做成協變。 但在函式參數中,我們常把 MutableList 用在兩種模式之一:
- 當元素來源(讀取,但不修改);
- 當接收端(新增元素)。
這時 use-site variance 就非常有幫助: MutableList<out T> 以及 MutableList<in T>。
別搞混:我們不是把 MutableList 永久做成協變。 我們是在說:「在這個函式裡,把它當成 producer / consumer 來對待。」
MutableList<out Number>:讀取數字,不新增
假設我們有 MutableList<Int>,但函式希望用 Number 來工作。 沒有投影時你會撞上型別不相容(可變集合是不變的), 但加上 out 投影後,只要你不新增元素,就一切正常。
fun sumFirstTwo(list: MutableList<out Number>): Double {
val a = list[0].toDouble()
val b = list[1].toDouble()
return a + b
// list.add(1) // 無法編譯:out 投影禁止寫入
}
fun main() {
val ints: MutableList<Int> = mutableListOf(10, 20, 30)
println(sumFirstTwo(ints)) // 30.0
}
這裡 Kotlin 讓我們避免一個微妙錯誤:如果允許寫入,我們就可能把 Double 加到 Int 的列表裡, 整個型別模型就會「走鐘」。
MutableList<in Int>:把 Int 加進合適的列表
現在反過來:函式必須新增 Int。同時,如果它也能接受更一般的列表會更好, 例如 MutableList<Number>。
fun addOne(list: MutableList<in Int>) {
list.add(1)
}
fun main() {
val numbers: MutableList<Number> = mutableListOf(10, 2.5)
addOne(numbers)
println(numbers) // [10, 2.5, 1]
}
這個契約的意思是:既然列表保證能接收 Int,那它的元素型別必然是 Int 或任何父型別 (Number、Any)。這就是 consumer 的邏輯。
5. out 與 in 速查表
剛開始使用投影時,大腦會先抗議:「為什麼我不能想怎樣就怎樣」。 為了讓大腦不要離職,最好準備一張短表。
讀完這段之後,每次編譯器跟你說「不行」時,你都可以回來查它。
| 參數中的投影 | 概念 | 適合做的事 | Kotlin 刻意讓你做起來更困難的事 |
|---|---|---|---|
|
來源 | 讀取 T | 寫入 T |
|
接收端 | 寫入 T | 以 T 讀取(通常只能讀成 Any?) |
這套邏輯直接源自 type projections(use-site variance)的概念,以及 Kotlin 對可能破壞型別安全的操作會直接禁止。
6. 範例:Finance Tracker 與 MutableList 上的投影
為了不把主題停留在「抽象的狗與貓」,我們把投影放進一段更接近現實的程式碼。
想像我們有一個主控台應用程式 Finance Tracker,用來儲存金融操作。 我們已經會儲存物件集合、撰寫函式並使用繼承,因此建立一個操作的基底型別與兩個子型別。
open class Operation(
val amount: Double,
val note: String,
)
class Expense(amount: Double, note: String) : Operation(amount, note)
class Income(amount: Double, note: String) : Operation(amount, note)
列印操作:producer MutableList<out Operation>
這個函式只需要讀取操作並輸出,不需要修改列表,否則它會變得太「霸道」。
fun printOperations(ops: MutableList<out Operation>) {
for (op in ops) {
println("${op::class.simpleName}: ${op.amount} (${op.note})")
// Output example: Expense: 12.5 (coffee)
}
}
fun main() {
val expenses: MutableList<Expense> = mutableListOf(
Expense(12.5, "coffee"),
Expense(40.0, "groceries"),
)
printOperations(expenses)
}
為什麼這很重要?因為沒有 out 的話,你無法把 MutableList<Expense> 傳到 需要「操作列表」的地方。而加上 out,你就明確宣告:這個列表在此被當成來源使用。
新增支出:consumer MutableList<in Expense>
接著是相反任務:函式要新增支出。如果它不只能新增到 MutableList<Expense>, 也能新增到通用日誌 MutableList<Operation>,就更實用。
fun addExpense(ops: MutableList<in Expense>, amount: Double, note: String) {
ops.add(Expense(amount, note))
}
fun main() {
val journal: MutableList<Operation> = mutableListOf(
Income(1000.0, "salary"),
)
addExpense(journal, 12.5, "coffee")
printOperations(journal)
// Income: 1000.0 (salary)
// Expense: 12.5 (coffee)
}
從型別角度來說:MutableList<Operation> 是很好的 Expense 接收端, 因為 Expense 是 Operation。
7. 投影限制的是「引用的 API」,不是物件本身
常見誤解:以為 Array<out Any> 是某種「特殊陣列」。 但實際上陣列還是同一個。改變的只是:你透過這個變數被允許做什麼。
可以把它想成一張小示意圖:
flowchart LR
A["真實物件:Array⟨Int⟩"]
B["引用型別為 Array⟨out Any⟩"]
C["引用型別為 Array⟨Int⟩"]
A --> B
A --> C
B -->|"可以讀取(Any)"| R["get(i)"]
B -.->|"不能寫入"| W["set(i, ...)"]
C -->|"可以讀取(Int)"| R2["get(i)"]
C -->|"可以寫入(Int)"| W2["set(i, Int)"]
從這個角度看,投影是一種很「工程化」的工具。 你不需要重寫資料模型;你只是對編譯器提出清楚限制:「在這個函式裡我會乖一點」。
8. 常見錯誤
錯誤 #1:嘗試往 Array<out …> 或 MutableList<out …> 裡「再寫入」。
通常表現是:你已經把參數謹慎宣告成 producer,但在函式內又突然想「我就加一點點」。 編譯器不會讓你這麼做,而且它是對的:如果你能把 MutableList<Int> 以 MutableList<out Number> 傳進來, 那寫入 2.5 會造成邏輯上的災難。
錯誤 #2:期待能從 Array<in …> 像從 Array<T> 一樣讀取。
若參數宣告為 consumer,Kotlin 會刻意讓讀取變得「不舒服」:安全的讀取型別通常會是 Any? 之類。 這是正常的。如果你同時需要以 T 讀取又要寫入 T,那就不是 consumer/producer 的情境——也許投影不適合用在這裡。
錯誤 #3:用 as 來解決泛型型別不相容,而不是用投影。
當你只想「讓它能編譯」,手就會想伸向 as。但在泛型中,型別轉換常把編譯期錯誤變成執行期驚喜。 投影的好處在於:它不會把問題藏起來,而是逼你誠實描述契約:「只讀」或「只寫」。
錯誤 #4:把投影和型別宣告處的 out/in 混為一談。
在型別宣告中使用 out 與 in,是你對類別/介面做出的設計決策(「這個型別天生是 producer」)。 在函式參數中的投影則是局部解法(「在這個函式裡我把容器當成 producer/consumer」)。 實務上這是不同層級的東西,建議心裡要能明確自言自語:「我現在是在設計型別,還是只是在寫一個安全的函式簽名」。
錯誤 #5:想寫一個同時讀又同時寫的萬用函式。
有時候會想「既要複製,又要順便改一點」,而且希望參數型別越寬越好。 但不變性正是在提醒你:如果你同時要讀與寫——請接受精確型別 (Array<T>、MutableList<T>)。 若想接受更寬的型別,就必須犧牲一些東西(通常是寫入能力或讀取的精確型別)。
GO TO FULL VERSION