概述

一般類和函式，只能使用具體的型別：要麼是基本型別，要麼是自定義的類。如果要編寫可以應用於多種型別的程式碼，這種刻板的約束對程式碼的限制很大。而OOP的多型採用了一種泛化的機制，在SE 5種，Java引用了泛型。泛型，即“引數化型別”。一提到引數，最熟悉的就是定義方法時有形參，然後呼叫此方法時傳遞實參。那麼引數化型別怎麼理解呢？顧名思義，就是將型別由原來的具體的型別引數化，類似於方法中的變數引數，此時型別也定義成引數形式（可以稱之為型別形參），然後在使用/呼叫時傳入具體的型別（型別實參）。

在Kotlin中，依然可以使用泛型，解耦類與函式與所用型別之間的約束，甚至是使用方法都與Java一致。

泛型類

宣告一個泛型類

class Box<T>(t: T) {
    var value = t
}

通常, 要建立這樣一個類的例項, 我們需要指定型別引數:

val box: Box<Int> = Box<Int>(1)

但是, 如果型別引數可以通過推斷得到, 比如, 通過構造器引數型別, 或通過其他手段推斷得到, 此時允許省略型別引數:

val box = Box(1) // 1 的型別為 Int, 因此編譯器知道我們建立的例項是 Box<Int> 型別

泛型函式

泛型函式與其所在的類是否是泛型沒有關係。泛型函式使得該函式能夠獨立於其所在類而產生變化。在<Thinking in Java>有這麼一句話：無論何時只要你能做到，你就應該儘量使用泛型方法，也就是說如果使用泛型方法可以取代將整個類泛型化，那麼就應該只使用泛型方法，因為它可以使事情更明白。這種泛型使用思想，在Kotlin中依然可以延續。

下面我們聲明瞭一個泛型函式doPrintln，當T是一個Int型別時，列印其個位的值；如果T是String型別，將字母全部大寫輸出；如果是其他型別，列印“T is not Int and String”。

fun main(args: Array<String>) {
    val age = 23
    val name = "Jone"
    val person = true

    doPrintln(age) // 列印：3
    doPrintln(name) // 列印：JONE
    doPrintln(person) // 列印：T is not Int and String
}

fun <T> doPrintln(content: T) {

    when (content) {
        is Int -> println(content % 10) 
        is String -> println(content.toUpperCase())
        else -> println("T is not Int and String")
    }
}
 

注：

1. 型別引數放在函式名稱之前。
2. 如果在呼叫處明確地傳入了型別引數, 那麼型別引數應該放在函式名稱 之後。如果不傳入引數型別，編譯器會根據傳入的值自動推斷引數型別。

擦除的神祕之處

下面我們先看一段程式碼：

class Box<T>(t : T) {
    var value = t
}


fun main(args: Array<String>) {
    var boxInt = Box<Int>(10)
    var boxString = Box<String>("Jone")

    println(boxInt.javaClass) // 列印：class com.teaphy.generic.Box
    println(boxString.javaClass) // 列印：class com.teaphy.generic.Box
}

現聲明瞭一個泛型類Box<T>,在不同的型別的型別在行為方面肯定不一樣，但是在我們獲取其所在類時，我們只是得到了“class com.teaphy.generic.Box”。在這裡我們不得不面對一個殘酷的現實：在泛型內部，無法獲得任何有關泛型引數型別的資訊。

不管是Java還是Kotlin，泛型都是使用擦除來實現的，這意味著當你在使用泛型時，任務具體的型別資訊都被擦除的，你唯一知道的就是你再使用一個物件。比如，Box<String>和Box<Int>在執行時是想的型別，都是Box的例項。在使用泛型時，具體型別資訊的擦除是我們不不懂得不面對的，在Kotlin中也為我們提供了一些可供參考的解決方案：

• 型別協變
• 型別投射
• 泛型約束

型別協變

在型別宣告時，使用協變註解修飾符(in或者out)。於這個註解出現在型別引數的宣告處, 因此我們稱之為宣告處的型別變異。如果在使用泛型時，使用了該型別編譯了會有什麼效果呢？

假設我們有一個泛型介面Source<in T, out R>, 其中T由協變註解in修飾，R由協變註解Out修飾.

internal interface Source<in T, out R> {
    fun mapT(t: T): Unit
    fun nextR(): R
}

• in T: 來確保Source的成員函式只能消費T型別，而不能返回T型別
• out R：來確保Source的成員函式只能返回R型別，而不能消費R型別

從上面的解釋中，我們可以清楚的知道了協變註解in和out的用意，其實際上是定義了型別引數在該類或者介面的用途，是用來消費的還是用來返回的，對其做了相應的限定。

型別投射

上面我們已經瞭解到了協變註解in和out的用意，下面我們將會用in和out，做一件有意義的事，看下面程式碼

fun copy(from: Array<out String>, to: Array<Any>) {
    // ...
}

fun fill(dest: Array<in String>, value: String) {
    // ...
}

對於copy函式中中，from的泛型引數使用了協變註解out修飾，意味著該引數不能在該函式中消費，也就是說在該函式中禁止對該引數進行任何操作。

對於fill函式中，dest的泛型引數使用了協變註解in修飾，Array<in String>與Java的 Array<? super String> 相同, 也就是說, 你可以使用CharSequence陣列,或者 Object 陣列作為 fill() 函式的引數

這種宣告在Kotlin中稱為型別投射(type projection)，型別投射的主要用於對引數做了相對因的限定，避免了對該引數類的不安全操作。

星號投射

有些時候, 你可能想表示你並不知道型別引數的任何資訊, 但是仍然希望能夠安全地使用它. 這裡所謂”安全地使用”是指, 對泛型型別定義一個型別投射, 要求這個泛型型別的所有的實體例項, 都是這個投射的子型別.

對於這個問題, Kotlin 提供了一種語法, 稱為 星號投射(star-projection):

• 假如型別定義為 Foo<out T> , 其中 T 是一個協變的型別引數, 上界(upper bound)為 TUpper ,Foo<> 等價於 Foo<out TUpper> . 它表示, 當 T 未知時, 你可以安全地從 Foo<> 中 讀取TUpper 型別的值.
• 假如型別定義為 Foo<in T> , 其中 T 是一個反向協變的型別引數, Foo<> 等價於 Foo<inNothing> . 它表示, 當 T 未知時, 你不能安全地向 Foo<> 寫入 任何東西.
• 假如型別定義為 Foo<T> , 其中 T 是一個協變的型別引數, 上界(upper bound)為 TUpper , 對於讀取值的場合, Foo<*> 等價於 Foo<out TUpper> , 對於寫入值的場合, 等價於 Foo<in Nothing> .

如果一個泛型型別中存在多個型別引數, 那麼每個型別引數都可以單獨的投射. 比如, 如果型別定義為interface Function<in T, out U> , 那麼可以出現以下幾種星號投射:

1. Function<*, String> , 代表 Function<in Nothing, String> ;
2. Function<Int, *> , 代表 Function<Int, out Any?> ;
3. Function<, > , 代表 Function<in Nothing, out Any?> .

注意: 星號投射與 Java 的原生型別(raw type)非常類似, 但可以安全使用

泛型約束

對於一個給定的型別引數, 所允許使用的型別, 可以通過泛型約束(generic constraint) 來限制。

上界

最常見的約束是 上界(upper bound)：

fun <T : Comparable<T>> sort(list: List<T>) {
    // ...
}

冒號之後指定的型別就是型別引數的 上界(upper bound): 對於型別引數 T , 只允許使用 Comparable<T>的子型別. 比如:

sort(listOf(1, 2, 3)) // 正確: Int 是 Comparable<Int> 的子型別
sort(listOf(HashMap<Int, String>())) // 錯誤: HashMap<Int, String> 不是
Comparable<HashMap<Int, String>> 的子型別

如果沒有指定, 則預設使用的上界是 Any? . 在定義型別引數的尖括號內, 只允許定義唯一一個上界. 如果同一個型別引數需要指定多個上界, 這時就需要使用單獨的 where 子句:

fun <T> cloneWhenGreater(list: List<T>, threshold: T): List<T> where T : Comparable,
T : Cloneable {
    return list.filter { it > threshold }.map { it.clone() }
}