Kotlin 知识梳理(12) 泛型类型参数

1、本文概要

本文是对<<Kotlin in Action>>的学习笔记，若是须要运行相应的代码能够访问在线环境 try.kotlinlang.org，这部分的思惟导图为：

2、泛型类型参数

泛型容许你定义带 类型形参 的类型，当这种类型的实例被建立出来的时候，类型形参被替换成为 类型实参 的具体类型。

和Java不一样，Kotlin始终要求类型实参要么被显示地说明，要么能被编译器推导出来。例如，在Java中能够声明List类型的变量，而不须要说明它能够包含哪些事物，而Kotlin从一开始就有泛型，因此它不支持原生态类型，类型实参必须定义。

2.1 泛型函数和属性

若是须要编写一个使用列表的函数，但愿它能够在任何列表上使用，须要编写一个泛型函数，泛型函数有它本身的类型形参，这些 类型形参 在每次调用时都必须替换成具体的 类型实参。

2.1.1 slice

例如集合当中slice函数的定义：

fun <T> List<T>.slice(indices : IntRange) : List<T>
复制代码

接收者和返回类型都用到了函数的类型形参T，它们的类型都是List<T>，当在一个具体的列表上调用这个函数时，能够显示地指定类型实参，也可让编译器自动推导出类型：

fun main(args: Array<String>) {
    val letters = ('a'..'z').toList()
    //显示地指定类型实参。
    println(letters.slice<Char>(0..2))
    //编译器自动推导出T的类型是Char。
    println(letters.slice(10..13))
}
复制代码

2.1.2 filter

下面再来看filter的例子

fun main(args: Array<String>) {
    val authors = listOf("first", "second")
    val readers = mutableListOf("first", "third")
    println(readers.filter { it !in authors })
}
复制代码

运行结果为：

>> [third]
复制代码

其中filter的定义为：

fun <T> List<T>.filter(predicate : (T) -> Boolean) : List<T> 
复制代码

在上面的例子中，自动生成的lambda参数it的类型为String。编译器推断T就是String，由于它知道函数是在List<T>上调用，而它的接收者readers的真实类型是List<String>。

2.1.3 声明泛型的扩展属性

咱们能够给 类或接口的方法、顶层函数、扩展函数和扩展属性 声明类型参数，在上面的例子中，类型参数用在了接收者和lambda参数上，下面咱们再来看一个 声明泛型的扩展属性 的例子：

val <T> List<T>.penultimate: T get() = this[size - 2]

fun main(args: Array<String>) {
    println(listOf(1, 2, 3, 4).penultimate)
}
复制代码

运行结果为：

>> 3
复制代码

2.1.4 不能声明泛型的非扩展属性

普通（非扩展）属性 不能拥有类型参数，不能在一个类型的属性中存储多个不一样类型的值，所以 声明泛型非扩展函数没有任何意义。

2.2 泛型类和泛型接口

Kotlin经过在类名称后加上一对尖括号，并把类型参数放在尖括号内来声明泛型类和泛型接口。一旦声明后，就能够在类型的主体内 像其它类型同样使用类型参数，例如List<T>：

interface List<T> {
    operator fun get(index : Int) : T } 复制代码

若是你的类继承了泛型类，或者实现了泛型接口，就得 为基础类型的泛型形参提供一个类型实参，它能够是一个 具体类型或者是另外一个类型形参。

2.2.1 将类型形参替换为具体类型

下面咱们先定义一个泛型类Holder<T>，再将它的类型形参替换为具体类型Int：

interface Holder<T> {
    fun getValue() : T fun setValue(t : T) } class HolderInt : Holder<Int> {
    var a : Int = 0;
    override fun getValue() = a override fun setValue(value : Int) {
        a = value
    }
}

fun main(args: Array<String>) {
    val t = HolderInt()
    t.setValue(2)
    println("value=${t.getValue()}")
}
复制代码

运行结果为：

>> value=2
复制代码

2.2.2 将类型形参替换为另外一个类型形参

HolderWrapper定义了它本身的类型参数T并把它指定为父类的类型参数，它是全新的类型形参，没必要保留同样的名称：

interface HolderWrapper<T> : Holder<T> 

class HolderInt : HolderWrapper<Int> {
    var a : Int = 0;
    override fun getValue() = a
    override fun setValue(value : Int) {
        a = value
    }
}
复制代码

2.2.3 类自身做为类型实参引用

一个类甚至能够把它本身做为类型实参引用，实现Comparable接口的类就是这种模式的经典例子，任何能够比较的元素都必须定义它如何与一样类型的对象比较。

interface Comparable<T> {
    fun compareTo(other : T) : Int } class String : Comparable<String> {
    override fun compareTo(other : String) : Int = /** **/
}
复制代码

String类实现了Comparable泛型接口，提供类型String给类型实参T。

2.3 类型参数约束

类型参数约束 能够限制做为 泛型类和泛型函数的类型实参的类型。例如计算列表元素之和的函数sum，它能够用在List<String>和List<Double>上，但不可用在List<String>上，能够 定义一个类型参数约束，说明sum的类型形参必须是数字。

若是你把一个类型指定为泛型类型形参的上界约束，在泛型类型具体的初始化中，其对应的类型实参就必须是这个具体类型或者它的子类型。约束的定义方式为：把冒号放在类型参数名称以后，做为类型形参上界的类型紧随其后，例如：

fun <T : Number> List<T>.sum() : T
复制代码

若是须要在一个类型参数上指定多个约束，须要使用不一样的语法：

fun <T> ensureTrailingPeriod(seq : T) 
        where T : CharSequence, T : Appendable {
        //...
}
复制代码

在这种状况下，做为类型实参的类型必须实现CharSequence和Appendable两个接口。

2.4 让类型实参非空

若是你声明的是泛型类或者泛型函数，包括可空的类型实参在内，任何类型实参均可以替换它的类型形参。事实上，没有指定上界的类型形参将会使用Any?做为默认的上界，关于Any的含义能够参考 Kotlin 知识梳理(7) - Kotlin 的类型系统 中的2.4节。

若是你想保证替换类型形参的始终是非空类型，能够经过指定一个约束来实现，若是除了可空性以外没有任何限制，那么能够使用Any代替默认的Any?做为上界。

class Processor<T : Any> {
    fun process(value : T) {
        value.hashCode()
    }
}
复制代码

除了Any以外，还能够指定任意非空类型做为上界，来让类型参数非空。

---

更多文章，欢迎访问个人 Android 知识梳理系列：

• Android 知识梳理目录：www.jianshu.com/p/fd82d1899…
• 我的主页：lizejun.cn
• 我的知识总结目录：lizejun.cn/categories/