kotlin 实战之泛型与逆变协变总结

Posted 2022-12-09 工匠若水

工匠若水可能会迟到，但是从来不会缺席，最终还是觉得将自己的云笔记分享出来吧 ～

特别说明，kotlin 系列文章均以 Java 差异为核心进行提炼，与 Java 相同部分不再列出。随着 kotlin 官方版本的迭代，文中有些语法可能会发生变化，请务必留意，语言领悟精髓即可，差异只是语法层面的事情，建议不要过多关注语法。

kotlin 泛型（generics）

与 java 一样，kotlin 的泛型用来表示变量类型的参数化。一个简单的泛型类定义使用样例：

class Generics<T>(t: T) 
    var tmp: T = t


/**
 运行结果：
 class java.lang.String
 class cn.yan.test.Generics
 class java.lang.String
 class cn.yan.test.Generics
 */
fun testRun() 
    val generics: Generics<String> = Generics<String>("666")
    println(generics.tmp.javaClass)
    println(generics.javaClass)

    //不像 java 没有<>就是 Object，kotlin 这里可以自动依据构造参数类型推断出是 String 类型
    val generics1 = Generics("666")
    println(generics1.tmp.javaClass)
    println(generics1.javaClass)

一个简单的泛型函数定义如下：

//泛型函数的定义声明
fun <T> get(t: T): T = t

/**
 调用
 */
fun testRun() 
    val v1 = get<String>("1233")
    val v2 = get<Int>(12)
    val v3 = get("1233")    //等价于v1，自动推断

泛型约束之协变（covariant）与逆变（controvariant）

关于泛型协变与逆变概念其实来自 java，在我们深入搞懂 kotlin 的泛型之前，我们有必要先巩固下 java 的泛型协变与逆变。以 java 代码为例子：

//【工匠若水 加微信 yanbo373131686 联系我，关注微信公众号：码农每日一题  未经允许严禁转载 https://blog.csdn.net/yanbober】

//java 代码

//表示可以往这个泛型集合放置任何类型对象
List<Object>

//表示可以往这个泛型集合只能放置String对象
List<String>

//在 java 中不能把 List<String> 类型变量赋值给 List<Object>，因为他们不是父子类关系
List<String> list1 = new ArrayList();
//假设如果这么做被允许，则我们做如下代码，list2.add(new Date()); String str = list.get(0); 这会导致类型转换异常。
List<Object> list2 = list1; //编译失败

我们知道，在 java 中为了解决上面赋值问题，其提供了类型通配符的概念。如下是一个 java 样例：

//java 代码

//表示我们可以给这个变量里面 add Object 类型成员或者 Object 子类类型成员。
List<? extends Object> list;

我们继续看一种 java 场景：

//【工匠若水 加微信 yanbo373131686 联系我，关注微信公众号：码农每日一题  未经允许严禁转载 https://blog.csdn.net/yanbober】

//java 代码

interface Collection<E> 
    void addAll(Collection<E> items);


void addAll(Collection<Object> to, Collection<Object> from) 
    //理论上我们觉得 String 可以赋值给 Object，但是普通泛型中他们没有直接关系。
    //无法编译通过，因为尝试赋值和接收的不是一个类型也不是父子类型关系。
    to.addAll(from);

通过 java 对上面案例的改进写法如下 java 案例：

//java 代码

interface Collection<E> 
    void addAll(Collection<? extends E> items);


void addAll(Collection<Object> to, Collection<String> from) 
    //通配符保证了编译通过，也可以安全的从 to 中读取元素，然后当作 Object 类型来使用。
    to.addAll(from);

通过上面例子可以发现，java 中Collection<String>是Collection<? extends Object>的子类型，但不是Collection<Object>的子类型。? extends用来限定类型的上界，也就是常说的协变，我们只能把它当作 extends 后面的 E 类型来读取，且读取是安全的类型转换，但是不能写入，写入会导致编译错误，因为写入可能是不安全的类型转换。反之，? super用来限定类型的下界，也就是常说的逆变，逆变是用来保证写入安全的，但是不能读取，有可能类型是不安全的转换。

我们如果只从中读取数据而不写入内容则称为协变，如果只向里面写入数据而不读取数据则称为逆变。

有了上面 java 泛型协变逆变的概念，现在我们再来看看 kotlin 的泛型。如下 kotlin 案例：

//【工匠若水 加微信 yanbo373131686 联系我，关注微信公众号：码农每日一题  未经允许严禁转载 https://blog.csdn.net/yanbober】

class Generics<T>(t: T) 
    private var tmp: T = t

    fun get(): T = this.tmp


/**
 运行结果：
 test
 */
fun testRun() 
    val t1 = Generics<String>("test")
    val t2: Generics<String> = t1
    println(t2.get())
    //编译报错 Type mismatch. Required: Generics<Any> Found: Generics<String>
    //val t3: Generics<Any> = t2

上面代码如果 t3 想编译通过需要修改代码为如下：

//kotlin 协变用 out 表示只能读取不能写入
class Generics<out T>(t: T) 
    private var tmp: T = t

    fun get(): T = this.tmp

    //编译错误 参数 t 爆红 Type parameter T is declared as 'out' but occurs in 'in' position in type T
    //fun set(t: T) = this.tmp = t


/**
 运行结果：
 test
 test
 */
fun testRun() 
    val t1 = Generics<String>("test")
    val t2: Generics<String> = t1
    println(t2.get())
    val t3: Generics<Any> = t2
    println(t3.get())

如上就能保证 t3 类型安全读取，但是可以看到 Generics 中的 set 方法是无法编译通过的，因为 T 是 out 的，只能读取不能当参数写入，所以要想写入得对上面代码改为如下：

//【工匠若水 加微信 yanbo373131686 联系我，关注微信公众号：码农每日一题  未经允许严禁转载 https://blog.csdn.net/yanbober】

//kotlin 协变用 out 表示只能读取不能写入
//kotlin 逆变用 in 表示只能写入不能读取
class Generics<out T, in M>(t: T, m: M) 
    private var tmp: T = t
    private var mm: M = m

    fun get(): T = this.tmp

    fun set(arg: M) 
        this.mm = arg
    


fun testRun() 
    val t1 = Generics<String, Number>("test", 12)
    val t2: Generics<String, Number> = t1
    t2.get()
    t2.set(12)
    val t3: Generics<Any, Int> = t2
    t3.get()
    t3.set(12)

如上代码体现的都是 kotlin 声明处协变和逆变的场景。

kotlin 泛型类型投影

由于 koltin 声明处协变逆变导致类型只能被读或者只能被写，不能读写操作。要想能同时读写就需要用到使用处协变逆变，也就是kotlin 类型投影。我们先看一个又想读也想写的例子，这个例子使用了 kotlin 的 Array 泛型，所以先看下其源码：

//kotlin 中的 Array.kt 源码
//由于 T 即被读也被写，所以如果按照 koltin 声明处协变规则来说，这里即不能加 in 也不能加 out
public class Array<T> 
    //对T的读取
    public operator fun get(index: Int): T
    //对T的写入
    public operator fun set(index: Int, value: T): Unit

接着我们使用它来一步步做到既能读也能写的能力，如下：

//【工匠若水 加微信 yanbo373131686 联系我，关注微信公众号：码农每日一题  未经允许严禁转载 https://blog.csdn.net/yanbober】

fun copy(from: Array<Any>, to: Array<Any>) 
    assertEquals(from.size, to.size)
    for (index in from.indices) 
        to[index] = from[index]
    


/**
 输出结果：
 hello0
 hello1
 */
fun testRun() 
    val from: Array<Int> = arrayOf(1, 2)
    val to: Array<Any> = Array<Any>(2)  it -> "hello$it" 
    to.forEach  println(it) 
    //编译报错 Type mismatch. Required: Array<Any> Found: Array<Int>
    //copy(from, to)

上面例子如果想要编译及运行通过就需要使用 kotlin 提供的类型投影机制，如下案例：

//这个 out 没在声明处，是在定义方法的地方
fun copy(from: Array<out Any>, to: Array<Any>) 
    assertEquals(from.size, to.size)
    for (index in from.indices) 
        to[index] = from[index]
        //编译报错，只能从 from 读，不能写入
        //form[index] = 1
    


/**
 输出结果：
 hello0
 hello1
 */
fun testRun() 
    val from: Array<Int> = arrayOf(1, 2)
    val to: Array<Any> = Array<Any>(2)  it -> "hello$it" 
    to.forEach  println(it) 
    copy(from, to)

kotlin 泛型星投影

如果Base<out T>里面 T 的上界是 TUpper，那么Base<*>就相当于Base<out T>，这表示当 T 的类型未知时，你可以安全的从Base<*>中读取TUpper类型的值。

如果Base<in T>里面 T 的下界是 TUpper，那么Base<*>就相当于Base<in Nothing>，Nothing 在 kotlin 中表示什么都不存在，所以无法向Base<*>中写入任何类型的值。

如果Base<T>里面 T 的上界是 TUpper，那么Base<*>就相当于读取时的Base<out TUpper>以及写入时的Base<in Nothing>。

如下是上面说法的验证实例：

//【工匠若水 加微信 yanbo373131686 联系我，关注微信公众号：码农每日一题  未经允许严禁转载 https://blog.csdn.net/yanbober】

class Base<out T>

class Base2<in T> 
    fun set(t: T) 
    


class Base3<T> (var t: T) 
    fun set(t: T) 
        this.t = t
    

    fun get(): T = this.t


/**
 测试使用
 */
fun testRun() 
    val base1: Base<Number> = Base<Int>()
    val base1a: Base<*> = base1

    val base2: Base2<Int> = Base2<Number>()
    base2.set(1)
    val base2a: Base2<*> = base2
    //编译报错 Out-projected type 'Base2<*>' prohibits the use of 'public final fun set(t: T): Unit defined in cn.yan.test.Base2'
    //base2a.set(3)

    val base3: Base3<Int> = Base3<Int>(12)
    base3.set(1)
    base3.get()
    val base3a: Base3<*> = base3
    base3a.get()
    //编译报错 Out-projected type 'Base3<*>' prohibits the use of 'public final fun set(t: T): Unit defined in cn.yan.test.Base3'
    //base3a.set(12)

上面案例就是 kotlin 泛型星投影的诠释。

kotlin 泛型擦除

在 jvm 平台下的 kotlin 与 java 类似，由于遵守 jvm 规范，所以对于泛型也存在擦除特性，所以 kotlin 语法层面的泛型检查有些时候是可以绕过的，因为本质到字节码层面都被擦除了。如下案例：

class Base<out T> (private var t: T) 
    fun get(): T = this.t

    //无法编译通过，因为 T 是 out 的，只能读不能写
    //fun set(t: T)  this.t = t 

    //kotlin 允许 @UnsafeVariance 注解来保证编译通过及能使用，但是安全不保证
    fun set(t: @UnsafeVariance T) 
        this.t = t
    


/**
 输出结果：
 12
 xxxxx
 */
fun testRun() 
    val base1: Base<Any> = Base<Int>(12)
    println(base1.get())
    //因为@UnsafeVariance的存在，这里可以写操作
    base1.set("xxxxx") //泛型擦除，所以可以存储，本质在字节码都是 Object，类似 java 泛型擦除
    println(base1.get())

到此暂时告一段落。

【工匠若水 加微信 yanbo373131686 联系我，关注微信公众号：码农每日一题 未经允许严禁转载 https://blog.csdn.net/yanbober】