Kotlin 基礎教程之泛型

更新時間：2017年06月30日 11:27:18 投稿：lqh

這篇文章主要介紹了Kotlin 基礎教程之泛型的相關資料,需要的朋友可以參考下

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

例如，泛型類：

class Hello<T>(val value: T)

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

泛型函數：

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

val list = foo<Int>(1)

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

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

類型變異

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

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

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

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

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

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

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

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

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

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

除了 out 之外, Kotlin 還提供了另一種類型變異注解: in. 這個注解導致類型參數反向類型變異(contravariant): 這個類型將只能被消費, 而不能被生產. 反向類型變異的一個很好的例子是 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) { /* ... */ }
}

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

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) // 錯誤: 期待的參數類型是 (Array<Any>, Array<Any>)

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

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

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

也可以使用 in 關鍵字來投射一個類型。

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

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

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

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

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

對于類型參數 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 泛型函數通過內聯函數可以獲取泛型的類型，比如：

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 }
}

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

您可能感興趣的文章: