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

Kotlin 知识梳理系列文章

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) - 泛型类型参数


一、本文概要

本文是对<<Kotlin in Action>>的学习笔记,如果需要运行相应的代码可以访问在线环境 try.kotlinlang.org,这部分的思维导图为:

二、泛型类型参数

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

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 {
        //...
}

在这种情况下,作为类型实参的类型必须实现CharSequenceAppendable两个接口。

2.4 让类型实参非空

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

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

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

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


更多文章,欢迎访问我的 Android 知识梳理系列:

推荐阅读更多精彩内容