Kotlin基础知识_12-泛型的高级特性_协变_逆变_实化

Kotlin基础知识_12-泛型的高级特性-协变&逆变&实化

泛型对于每个开发者而言并不陌生，平时在项目中会经常见到，但是有很多小伙伴们，每次见到通配符 ? extends ,? super,out,in 都傻傻分不清楚它们的区别，以及在什么情况下使用。

通过这篇文章将会学习的到以下内容:

• 为什么要有泛型
• Kotlin 和 Java 的协变
• Kotlin 和 Java 的逆变
• 通配符 ? extends 、 ? super 、 out 、 in 的区别和应用场景
• Kotlin 和 Java 数组协变的不同之处
• 数组协变的缺陷
• 协变和逆变的应用场景

1. 为什么要有泛型

在 Java 和 Kotlin 中我们常用集合（ List 、 Set 、 Map 等等）来存储数据，而在集合中可能存储各种类型的数据，现在我们有四种数据类型 Int 、 Float 、 Double 、 Number，假设没有泛型，我们需要创建四个集合类来存储对应的数据。

class IntList{ }
class Floatlist{}
class DoubleList{}
class NumberList{}
......
更多

如果有更多的类型，就需要创建更多的集合类来保存对应的数据，这显然是不可能的，而泛型是一个 "万能的类型匹配器"，同时又能让编译器保证类型安全。

泛型将具体的类型（ Int 、 Float 、 Double 等等）声明的时候使用符号来代替，使用的时候，才指定具体的类型：

// 声明的时候使用符号来代替
class List<E>{
}

// 在 Kotlin 中使用，指定具体的类型
val data1: List<Int> = List()
val data2: List<Float> = List()

// 在 Java 中使用，指定具体的类型
List<Integer> data1 = new List();
List<Float> data2 = new List();

泛型很好的帮我们解决了上面的问题，但是随之而来出现了新的问题，我们都知道 Int 、 Float 、 Double 是 Number 的子类型, 因此下面的代码是可以正常运行的。

// Kotlin
val number: Number = 1

// Java
Number number = 1;

我们花三秒钟思考一下，下面的代码是否可以正常编译。

List<Number> numbers = new ArrayList<Integer>();

答案是不可以的，正如下图所示，编译器会报错：

这也就说明了泛型是不可变的，IDE 认为 ArrayList<Integer> 不是 List<Number> 子类型，不允许这么赋值，那么如何解决这个问题呢，这就需要用到协变了，协变能够允许上面的赋值是合法的。

2. Kotlin 和 Java 的协变

• 在 Java 中用上界通配符 ? extends T 表示协变，extends 限制了父类型 T，其中 ? 表示未知类型，比如 <? extends Number>，表示只要使用时传入的类型是 Number 或者 Number 的子类型都可以。
• 在 Kotlin 中关键字 out T 表示协变，含义和 Java 一样。

上界通配符

在继承关系树中，子类继承自父类，可以认为父类在上，子类在下。？ extends T 限制了泛型类型的父类型，所以叫上界。

现在我们将上面的代码修改一下，在花三秒钟思考一下，下面的代码是否可以正常编译。

// kotlin
val numbers: MutableList<out Number> = ArrayList<Int>()

// Java
List<? extends Number> numbers = new ArrayList<Integer>();

答案是可以正常编译的，协变通配符 ? extends Number 或者 out Number 表示集合中的对象接受 Number 或者 Number 子类型，协变放宽了对数据类型的约束，但是放宽是有代价的，我们在花三秒钟思考一下，下面的代码是否可以正常编译。

// Koltin
val numbers: MutableList<out Number> = ArrayList<Int>()
numbers.add(1)

// Java
List<? extends Number> numbers = new ArrayList<Integer>();
numbers.add(1)

答案是不可以的，调用 add() 方法会编译失败，虽然协变放宽了对数据类型的约束，可以接受 Number 或者 Number 子类型作为集合中的元素，但是代价是 无法添加元素，只能获取元素，因此协变只能作为生产者，对外提供数据。

为什么无法添加元素？

因为 ? 表示未知类型，所以编译器也不知道会往集合中添加什么类型的数据，因此索性不允许往集合里添加元素。如果允许添加元素会有什么后果？

public static void main(String[] args) {
    List<? extends Number> numbers = new ArrayList<Integer>();
    numbers.add(1);             // 假设能够编译通过
    numbers.add(1.0f);          // 假设能够编译通过
    numbers.get(0);             // 如果其它调用者调用了get(),那这里get得到的是什么类型？ Int or Float?
}

但是如果想让上面的代码编译通过，想往集合中添加元素，这就需要用到逆变了。

3. Kotlin 和 Java 的逆变

• 在 Java 中使用下界通配符 ? super T 表示逆变，其中 ? 表示未知类型，super 主要限制了未知类型的子类型 T，比如 ? super Number，表示只要使用时传入的是 Number 或者 Number 的父类型都可以；
• 在 Kotlin 中关键字 in T 表示逆变，含义和 Java 一样

下界通配符

与上界通配符对应，这里 super 限制了通配符 ? 的子类型，所以称之为下界。

现在我们将上面的代码简单修改一下，在花三秒钟思考一下是否可以正常编译。

// Kotlin
val numbers: MutableList<in Number> = ArrayList<Number>()
numbers.add(100)

// Java
List<? super Number> numbers = new ArrayList<Number>();
numbers.add(100);

答案可以正常编译的，逆变通配符 ? super Number 或者关键字 in 将继承关系颠倒过来，主要用来限制未知类型的子类型，在上面的例子中，编译器知道子类型是 Number，因此只要是 Number 的父类都可以添加。

逆变可以往集合中添加元素，那么可以获取元素吗？我们花三秒钟时间思考一下，下面的代码是否可以正常编译。

// Kotlin
val numbers: MutableList<in Number> = ArrayList<Number>()
numbers.add(100)
numbers.get(0)

// Java
List<? super Number> numbers = new ArrayList<Number>();
numbers.add(100);
numbers.get(0);

无论调用 add() 方法还是调用 get() 方法，都可以正常编译通过，现在将上面的代码修改一下，思考一下是否可以正常编译通过。

// Kotlin
val numbers: MutableList<in Number> = ArrayList<Number>()
numbers.add(100)
val item: Int = numbers.get(0) // 编译失败

// Java
List<? super Number> numbers = new ArrayList<Number>();
numbers.add(100);
int item = numbers.get(0);	   // 编译失败

调用 get() 方法会编译失败，因为 numbers.get(0) 获取的的值是 Object 的类型，因此它不能直接赋值给 int 类型，逆变和协变一样，放宽了对数据类型的约束，但是代价是 不能按照泛型类型读取元素，也就是说往集合中添加 int 类型的数据，调用 get() 方法获取到的不是 int 类型的数据。

为什么无法直接转换为int类型？

因为add()方法加入 int类型是允许的，而且本来就是这样约定的(允许加入Number及Number的父类型), 编译器只知道里面是Number或Number的父类型，可具体是什么类型不知道，不过也没关系，反正所有类型的父类型都是Object类型就是了，根据java多态的特性，用Object声明总不会错的，所以这样写是对的：

public static void main(String[] args) {
    List<? super Number> numbers = new ArrayList<Number>();
    numbers.add(100);
    Object obj = numbers.get(0);
    int a = (Integer) obj;
}

但是想要获取原始类型的话，就需要你自己进行强制转换了，如果强转失败，编译器不负责。

对这一小节内容，我们简单的总结一下。

关键字（Java/Kotlin）	添加	读取
协变	? extends / out	❎	✅
逆变	? super / in	✅	❎

4. Kotlin 和 Java 数组协变的不同之处

无论是 Kotlin 还是 Java 它们协变和逆变的含义的都是一样的，只不过通配符不一样，但是他们也有不同之处。

Java 是支持数组协变的，代码如下所示：

Number[] numbers = new Integer[10];

但是 Java 中的数组协变有缺陷，将上面的代码修改一下，如下所示。

Number[] numbers = new Integer[10];
numbers[0] = 1.0;

可以正常编译，但是运行的时候会崩溃。

因为最开始我将 Number[] 协变成 Integer[]，接着往数组里添加了 Double 类型的数据，所以运行会崩溃。

而 Kotlin 的解决方案非常的干脆，不支持数组协变，编译的时候就会出错，对于数组逆变 Koltin 和 Java 都不支持。

5. 协变和逆变的应用场景

协变和逆变应用的时候需要遵循 PECS（Producer-Extends, Consumer-Super）原则，即 ? extends 或者 out 作为生产者，? super 或者 in 作为消费者。遵循这个原则的好处是，可以在编译阶段保证代码安全，减少未知错误的发生。

协变应用

• 在 Java 中用通配符 ? extends 表示协变
• 在 Kotlin 中关键字 out 表示协变

协变只能读取数据，不能添加数据，所以只能作为生产者，向外提供数据，因此只能用来输出，不用用来输入。

在 Koltin 中一个协变类，参数前面加上 out 修饰后，这个参数在当前类中 只能作为函数的返回值，或是修饰只读属性 ，代码如下所示。

// 正常编译
interface ProduceExtends<out T> {
   val num: T          // 用于只读属性
   fun getItem(): T    // 用于函数的返回值
}

// 编译失败
interface ProduceExtends<out T> {
   var num : T         // 用于可变属性
   fun addItem(t: T)   // 用于函数的参数
}

当我们确定某个对象只作为生产者时，向外提供数据，或者作为方法的返回值时，我们可以使用 ? extends 或者 out。

• 以 Kotlin 为例，例如 Iterator#next() 方法，使用了关键字 out，返回集合中每一个元素:

  

• 以 Java 为例，例如 ArrayList#addAll() 方法，使用了通配符 ? extends

  

  传入参数 Collection<? extends E> c 作为生产者给 ArrayList 提供数据。

逆变应用

• 在 Java 中使用通配符 ? super 表示逆变
• 在 Kotlin 中使用关键字 in 表示逆变

逆变只能添加数据，不能按照泛型读取数据，所以只能作为消费者，因此只能用来输入，不能用来输出。

在 Koltin 中一个逆变类，参数前面加上 in 修饰后，这个参数在当前类中 只能作为函数的参数，或者修饰可变属性 。

// 正常编译，用于函数的参数
interface ConsumerSupper<in T> {
   fun addItem(t: T)
}

// 编译失败，用于函数的返回值
interface ConsumerSupper<in T> {
   fun getItem(): T
}

当我们确定某个对象只作为消费者，当做参数传入时，只用来添加数据，我们使用通配符 ? super 或者关键字 in:

• 以 Kotlin 为例，例如扩展方法 Iterable#filterTo()，使用了关键字 in，在内部只用来添加数据:

  

• 以 Java 为例，例如 ArrayList#forEach() 方法，使用了通配符 ? super

  

另外，在上面的源码中，分别使用了不同的泛型标记符 T 和 E，其实我们稍微注意一下，在源码中有几个高频的泛型标记符 T 、 E 、 K 、 V 等等，它们分别应用在不同的场景。

标记符	应用场景
T（Type）	类
E（Element）	集合
K（Key）	键
V（Value）	值

6. 一些例外的情况 - @UnsafeVariance注解

前面有提到过 ：

在 Koltin 中一个协变类，参数前面加上 out 修饰后，这个参数在当前类中 只能作为函数的返回值，或是修饰只读属性

虽然是这样约定的，但仍然有办法能够绕过：比如kotln 内置的 List类型，我们来看一下List简化版的源码：

public interface List<out E> : Collection<E> {
	override val size: Int
	override fun isEmpty(): Boolean
	override fun contains(element: @UnsafeVariance E): Boolean
	override fun iterator(): Iterator<E>
	public operator fun get(index: Int): E
}

List在泛型E的前面加上了out关键字，说明List在泛型E上是协变的。按照之前的约定，原则上在声明了协变之后，泛型E就只能出现在out位置上，也就是说只能作为函数返回值，不能作为函数参数，可是你会发现，在contains()方法中，泛型E仍然出现在了in位置上，即：还是把E作为了函数参数。

这么写本身是不合法的，因为在in位置上出现了泛型E就意味着会有类型转换的安全隐患。但是contains()方法的目的非常明确，它只是为了判断当前集合中是否包含参数中传入的这个元素，而并不会修改当前集合中的内容，因此这种操作实质上又是安全的。那么为了让编译器能够理解我们的这种操作是安全的，这里在泛型E的前面又加上了一个@UnsafeVariance注解，这样编译器就会允许泛型E出现在in位置上了。但是如果你滥用这个功能，导致运行时出现了类型转换异常，Kotlin对此是不负责的。

7. 泛型的实化

java 实际上是没有真正的泛型的，java的泛型功能实际上通过 类型擦除机制实现的，所以在运行时无法得知泛型的具体类型，像T.class这种语法在java中是不被允许的。

kotlin因为有内联函数的特性，所以可实现真正的泛型实化，即：能够在程序运行时得到泛型的真实类型。

inline fun <reified T> getRealType(obj: T) = T::class.java

fun main() {
    val a = getRealType("123")
    val b = getRealType(123)

    println("a's type: $a, b's type: $b")
}

运行：

a's type: class java.lang.String, b's type: class java.lang.Integer

使用泛型实化这个功能需要注意：

• 该函数必须是内联函数，也就是说函数必须使用 inline关键字声明；
• 声明的泛型必须加上kotlin关键字 reified。

举例：Activity 跳转：

旧的写法：

mViewBinding.btnSkip.setOnClickListener {
    startActivity(Intent(applicationContext, SecondActivity::class.java))
}

新的写法：

inline fun <reified T> startActivity() {
    startActivity(Intent(applicationContext, T::class.java))
}

// 跳转
mViewBinding.btnSkip.setOnClickListener {
    startActivity<SecondActivity>()
}

后一种写法也可以的，可以在运行时根据传入的泛型类型，动态跳转到指定的Activity。

扩展阅读：Java的类型擦除机制

在JDK 1.5之前，Java是没有泛型功能的，那个时候诸如List之类的数据结构可以存储任意类型的数据，取出数据的时候也需要手动向下转型才行，这不仅麻烦，而且很危险。比如说我们在同一个List中存储了字符串和整型这两种数据，但是在取出数据的时候却无法区分具体的数据类型，如果手动将它们强制转成同一种类型，那么就会抛出类型转换异常。

于是在JDK 1.5中，Java终于引入了泛型功能。这不仅让诸如List之类的数据结构变得简单好用，也让我们的代码变得更加安全。

但是实际上，Java的泛型功能是通过类型擦除机制来实现的。什么意思呢？就是说泛型对于类型的约束只在编译时期存在，运行的时候仍然会按照JDK 1.5之前的机制来运行，JVM是识别不出来我们在代码中指定的泛型类型的。例如，假设我们创建了一个List<String>集合，虽然在编译时期只能向集合中添加字符串类型的元素，但是在运行时期JVM并不能知道它本来只打算包含哪种类型的元素，只能识别出来它是个List。

参考链接

1. Kotlin和Java的协变和逆变
2. Kotlin的泛型