Kotlin 语言学习(12) - 泛型类型参数

Kotlin 语言学习(1) - Kotlin 基础

Kotlin 语言学习(2) - 函数的定义与调用

Kotlin 语言学习(3) - 类、对象和接口

Kotlin 语言学习(4) - 数据类、类委托 及 object 关键字

Kotlin 语言学习(5) - lambda 表达式和成员引用

Kotlin 语言学习(6) - Kotlin 的可空性

Kotlin 语言学习(7) - Kotlin 的类型系统

Kotlin 语言学习(8) - 运算符重载及其他约定

Kotlin 语言学习(9) - 委托属性

Kotlin 语言学习(10) - 高阶函数：Lambda

Kotlin 语言学习(11) - 内联函数

Kotlin 语言学习(12) - 泛型类型参数

一、本文概要

 二、泛型类型参数

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

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

2.1 泛型函数和属性

如果需要编写一个使用列表的函数，希望它可以在任何列表上使用，需要编写一个泛型函数，泛型函数有它自己的类型形参，这些 类型形参 在每次调用时都必须替换成具体的 类型实参。

2.1.1 slice

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

fun  List.slice(indices : IntRange) : List

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

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

2.1.2 filter

下面再来看filter的例子：

fun main(args: Array) {
    val authors = listOf("first", "second")
    val readers = mutableListOf("first", "third")
    println(readers.filter { it !in authors })
}

运行结果为：

>> [third]

其中filter的定义为：

fun  List.filter(predicate : (T) -> Boolean) : List 

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

2.1.3 声明泛型的扩展属性

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

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

fun main(args: Array) {
    println(listOf(1, 2, 3, 4).penultimate)
}

运行结果为：

>> 3

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

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

2.2 泛型类和泛型接口

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

interface List {
    operator fun get(index : Int) : T
}

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

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

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

interface Holder {
    fun getValue() : T
    fun setValue(t : T)
}

class HolderInt : Holder {
    var a : Int = 0;
    override fun getValue() = a
    override fun setValue(value : Int) {
        a = value
    }
}

fun main(args: Array) {
    val t = HolderInt()
    t.setValue(2)
    println("value=${t.getValue()}")
}

运行结果为：

>> value=2

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

HolderWrapper定义了它自己的类型参数T并把它指定为父类的类型参数，它是全新的类型形参，不必保留一样的名称：

interface HolderWrapper : Holder 

class HolderInt : HolderWrapper {
    var a : Int = 0;
    override fun getValue() = a
    override fun setValue(value : Int) {
        a = value
    }
}

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

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

interface Comparable {
    fun compareTo(other : T) : Int
}

class String : Comparable {
    override fun compareTo(other : String) : Int = /** **/
}

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

2.3 类型参数约束

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

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

fun  List.sum() : T

如果需要在一个类型参数上指定多个约束，需要使用不同的语法：

fun  ensureTrailingPeriod(seq : T) 
        where T : CharSequence, T : Appendable {
        //...
}

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

2.4 让类型实参非空

如果你声明的是泛型类或者泛型函数，包括可空的类型实参在内，任何类型实参都可以替换它的类型形参。事实上，没有指定上界的类型形参将会使用Any?作为默认的上界。

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

class Processor {
    fun process(value : T) {
        value.hashCode()
    }
}

除了Any之外，还可以指定任意非空类型作为上界，来让类型参数非空。

see you