例如，泛型類：
|
1
2
3
4
|
class Hello<T>(val value: T)val box = Box<Int>(1)val box1 = Box(2) |
泛型函數：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
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 的方法：
|
1
2
3
4
5
6
7
8
9
|
// Javainterface 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 修飾符:
|
1
2
3
4
5
6
7
|
abstract class Source<out T> { abstract fun nextT(): T}fun demo(strs: Source<String>) { val objects: Source<Any> = strs // 這是 OK 的, 因為 T 是一個 out 類型參數 // ...} |
一般規則是: 當 C 類的類型參數 T 聲明為 out 時, 那么在 C 的成員函數中, T 類型只允許出現在輸出位置, 這樣的限制帶來的回報就是, C<Base> 可以安全地用作 C<Derived> 的父類型。
除了 out 之外, Kotlin 還提供了另一種類型變異注解: in. 這個注解導致類型參數反向類型變異(contravariant): 這個類型將只能被消費, 而不能被生產. 反向類型變異的一個很好的例子是 Comparable :
|
1
2
3
4
5
6
7
8
9
|
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)
|
1
2
3
4
|
class Array<T>(val size: Int) { fun get(index: Int): T { /* ... */ } fun set(index: Int, value: T) { /* ... */ }} |
這個類對于類型參數 T 既不能協變, 也不能反向協變. 這就帶來很大的不便。
|
1
2
3
4
5
6
7
8
9
|
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 數組
寫入 數據, 我們可以這樣聲明:
|
1
2
3
|
fun copy(from: Array<out Any>, to: Array<Any>) { // ...} |
這種聲明在 Kotlin 中稱為 類型投射(type projection): 我們聲明的含義是, from 不是一個單純的數組, 而是
一個被限制(投射)的數組: 我們只能對這個數組調用那些返回值為類型參數 T 的方法。
也可以使用 in 關鍵字來投射一個類型。
|
1
2
3
|
fun fill(dest: Array<in String>, value: String) { // ...} |
- 星號投射(Star-projection)
- 泛型約束(Generic constraint)
對于一個給定的類型參數, 所允許使用的類型, 可以通過 泛型約束(generic constraint) 來限制。
最常見的約束是 上界(upper bound), 與 Java 中的 extends 關鍵字相同:
|
1
2
3
|
fun <T : Comparable<T>> sort(list: List<T>) { // ...} |
對于類型參數 T , 只允許使用 Comparable<T> 的子類型. 比如:
|
1
2
3
|
sort(listOf(1, 2, 3)) // 正確: Int 是 Comparable<Int> 的子類型sort(listOf(HashMap<Int, String>())) // 錯誤: HashMap<Int, String> 不是 // Comparable<HashMap<Int, String>> 的子類型 |
泛型類型
Java 里面的泛型不支持類型， 比如 T.class這樣的代碼獲取不到類型。Kotlin 泛型函數通過內聯函數可以獲取泛型的類型，比如：
|
1
2
3
4
5
6
7
|
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 }} |
感謝閱讀，希望能幫助到大家，謝謝大家對本站的支持！
原文鏈接：http://www.jianshu.com/p/9fd311a1f4dd
