Kotlin 支持泛型， 語法和 Java 類似。

例如，泛型類：

class Hello<T>(val value: T)

val box = Box<Int>(1)
val box1 = Box(2)

泛型函數(shù)：

fun <T> foo(item: T): List<T> {
  // do something
}

val list = foo<Int>(1)

fun <T> T.toString2(): String {
  // 擴(kuò)展函數(shù)
}

fun <K, V>put(key: K, value: V) {
  // 多個泛型參數(shù)
}

類型變異

Java 的泛型中，最難理解的就是通配符。Java 中使用通配符是由于泛型類型是不可變的，比如 List<String>不是List<Object>的子類， 因而 List<Object> objs = strs 這樣的代碼有編譯錯誤。

為了解決此問題，Java 提供了通配符類型參數(shù)(wildcard type argument)。如果你只能從一個集合取得元素, 那么就可以使用一個 String 組成的集合, 并從中讀取 Object 實(shí)例，這個時(shí)候用? extends T. 反過來, 如果你只能向集合 放入 元素, 那么就可以使用一個 Object 組成的集合, 并向其中放入 String, 這個時(shí)候用? super T。

Kotlin 不存在這樣的通配符，提供了兩種方法：聲明處類型變異(declaration-sitevariance), 以及類型投射(type projection)。

假設(shè)我們有一個泛型接口 Source<T> , 其中不存在任何接受 T 作為參數(shù)的方法, 僅有返回值為 T 的方法：

// Java
interface Source<T> {
  T nextT();
}

void demo(Source<String> strs) {
  Source<Object> objects = strs; // !!! 在 Java 中禁止這樣的操作
  // ...
}

為了解決這個問題, 我們不得不將對象類型聲明為 Source<? extends Object> , 其實(shí)是毫無意義的, 編譯器并不理解這一點(diǎn)。

在 Kotlin 中, 我們有辦法將這種情況告訴編譯器. 這種技術(shù)稱為聲明處的類型變異(declaration-sitevariance): 我們可以對 Source 的 類型參數(shù) T 添加注解, 來確保 Source<T> 的成員函數(shù)只會返回T 類型, 而絕不會消費(fèi) T 類型. 為了實(shí)現(xiàn)這個目的, 我們可以對 T 添加 out 修飾符:

abstract class Source<out T> {
  abstract fun nextT(): T
}
fun demo(strs: Source<String>) {
  val objects: Source<Any> = strs // 這是 OK 的, 因?yàn)?T 是一個 out 類型參數(shù)
  // ...
}

一般規(guī)則是: 當(dāng) C 類的類型參數(shù) T 聲明為 out 時(shí), 那么在 C 的成員函數(shù)中, T 類型只允許出現(xiàn)在輸出位置, 這樣的限制帶來的回報(bào)就是, C<Base> 可以安全地用作 C<Derived> 的父類型。

除了 out 之外, Kotlin 還提供了另一種類型變異注解: in. 這個注解導(dǎo)致類型參數(shù)反向類型變異(contravariant): 這個類型將只能被消費(fèi), 而不能被生產(chǎn). 反向類型變異的一個很好的例子是 Comparable :

abstract class Comparable<in T> {
  abstract fun compareTo(other: T): Int
}

fun demo(x: Comparable<Number>) {
  x.compareTo(1.0) // 1.0 類型為 Double, 是 Number 的子類型
  // 因此, 我們可以將 x 賦值給 Comparable<Double> 類型的變量
  val y: Comparable<Double> = x // OK!
}

類型投射(Type projection)

class Array<T>(val size: Int) {
  fun get(index: Int): T { /* ... */ }
  fun set(index: Int, value: T) { /* ... */ }
}

這個類對于類型參數(shù) T 既不能協(xié)變, 也不能反向協(xié)變. 這就帶來很大的不便。

fun copy(from: Array<Any>, to: Array<Any>) {
  assert(from.size == to.size)
  for (i in from.indices)
    to[i] = from[i]
}

val ints: Array<Int> = arrayOf(1, 2, 3)
val any = Array<Any>(3)
copy(ints, any) // 錯誤: 期待的參數(shù)類型是 (Array<Any>, Array<Any>)

我們需要確保的就是 copy() 函數(shù)不會做這類不安全的操作. 我們希望禁止這個函數(shù)向 from 數(shù)組
寫入 數(shù)據(jù), 我們可以這樣聲明:

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

這種聲明在 Kotlin 中稱為 類型投射(type projection): 我們聲明的含義是, from 不是一個單純的數(shù)組, 而是
一個被限制(投射)的數(shù)組: 我們只能對這個數(shù)組調(diào)用那些返回值為類型參數(shù) T 的方法。

也可以使用 in 關(guān)鍵字來投射一個類型。

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

• 星號投射(Star-projection)
• 泛型約束(Generic constraint)

對于一個給定的類型參數(shù), 所允許使用的類型, 可以通過 泛型約束(generic constraint) 來限制。

最常見的約束是 上界(upper bound), 與 Java 中的 extends 關(guān)鍵字相同:

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

對于類型參數(shù) T , 只允許使用 Comparable<T> 的子類型. 比如:

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

泛型類型

Java 里面的泛型不支持類型， 比如 T.class這樣的代碼獲取不到類型。Kotlin 泛型函數(shù)通過內(nèi)聯(lián)函數(shù)可以獲取泛型的類型，比如：

inline fun <reified T>runtimeType(): Unit {
  println("My type parameter is " + T::class.qualifiedName)
}

inline fun <reified T>List<Any>.collect(): List<T> {
  return this.filter { it is T }.map { it as T }
}

感謝閱讀，希望能幫助到大家，謝謝大家對本站的支持！