深入理解Kotlin中的泛型（协变、逆变）。

一、泛型的必要性

【1.1】没有泛型之前

在说明为什么有泛型之前，我们先看一段代码

List AList = new ArrayList();
//编译通过，运行不报错
A.add(new B());
//编译通过，运行报错
A a = (A) A.get(0);

这段代码，现在已经很少看到了。但实际上在Java1.5之前，这是很经常写的代码，也很容易犯错的代码。在上面的代码中，我们声明了一个不知道储存什么类型的List。虽然我们通过变量名“AList”来代表这个List是存，取A类型的集合。但是我们仍然可以将B类型的对象存进去。而且取出来的时候，我们还需要进行类型强转。这就带来了两个问题：

1. 我们无法在储存的时候，就限定输入的类型。导致可能存入其他类型导致CastClassException。
2. 集合元素取出来的时候，我们明明知道是A类型的，但是每次还是都要进行一次强转。

出现这问题的原因根本在于，ArrayList()底层是使用Object[]实现的。这样设计的本意是可以让ArrayList更加的通用，适用于一切类型。

【1.2】有了泛型之后

在了解了上面的需求和痛点后，我们可以很自然的想起泛型。它可以让类型参数化。在引入泛型后。上面的代码我们可以这样写：

List AList = new ArrayList();
//编译不通过。
A.add(new B());
//不再需要强转
A a = A.get(0);

可以看到，在引入了泛型后，在编译时就能进行类型检查。但是ArrayList底层实现还是使用Object[]的，为什么可以不用进行类型强转呢？
我们可以看一下ArrayList.get()方法：

ArrayList.java

transient Object[] elementData;
public E get(int index) {
    rangeCheck(index);
    return elementData(index);
}

E elementData(int index) {
    return (E) elementData[index]; //内部进行类型强转
}

【1.3】泛型的必要性总结

到这里，我们总结一下引入泛型的好处：

1. 类型安全：编译器可以在编译时期就对类型错误的存取报错。
2. 类型参数化，可以写出更加通用的代码。
3. 简化代码。
4. 可以自动进行类型转化，获取数据是可以不用进行类型强转

二、泛型的实现：类型擦除

【2.1】泛型的实际实现

其实关于泛型的背后实现，我们在上面有说到了一些。为了更加深刻的体会他是通过类型擦除的方式来实现泛型的，我们看一下如下代码的字节码：

//没有加泛型
ArrayList list = new ArrayList();
//加了泛型
ArrayList AList = new ArrayList();

字节码：

//ArrayList list = new ArrayList();
0:  new               #2
3:  dup
4:  invokespecial     #3
7:  astore+1
//ArrayList AList = new ArrayList();
8:  new               #2
11: dup          
12: invokespecial     #3
15: astore_2

可以看到，ArrayList无论有没有加泛型，它的字节码都是一样的。那么它是怎么保证我们在一所说的泛型带来的特性呢？其实类型检查可以通过编译器检查来实现。而类型自动转化就如我们上面看到的一样，通过泛型类内部强转实现。

【2.2】为什么采用类型擦除实现泛型？

在了解了泛型的实现机制以后，我们反过来思考一下，Java为什么采用类型擦除的方式来实现泛型。答案是：向后兼容。 我们知道向后兼容是Java一强调的一大特性，而在Java1.5之前，还没有出现泛型的时期，必然出现了大量如下代码：

ArrayList list = new ArrayList();

而类型擦除的方式实现泛型，我们可以看到其编译出来的字节码，和1.5之前的是一样的，可以说是完全兼容。然后泛型的一些特性通过编译器和对现有集合框架类的改造实现。那Kotlin号称是可以完全兼容Java的，所以Kotlin的泛型实现方式当然也是和Java一样的了。

【2.3】泛型类型的获取

通过上面中我们知道，为了是提升代码的通用型，我们使用泛型使类型参数化，抹去了不同类型带来的差异。但是在我们编码过程中，我们时常需要在运行中获取对象类型，而经过类型擦除的泛型类，已经失去了类型参数的信息，那么我们有什么办法可以运行中获取这个类型参数吗。或许我们可以通过手动指定的方式获取。具体的代码如下：

open class A(val data: T, val clazz: Class) {

    fun getType() {
        println(clazz)
    }

}

总结：这种方式获取泛型类型参数难免麻烦了一点，而且它不能获取一个获取一个泛型类型。比如：

//编译不同过，报错
Class clazz = ArrayList.class

那么我们有没有办法获取一个泛型类型呢，答案是有的：

【2.3.1】利用匿名内部类获取泛型类型

val listA = new ArryaList()
val listA2 = object : ArrayList(){}

println(listA.javaClass.genericSuperclass)
println(lstA2.javaClass.genericSuperclass)

//打印：
java.util.AbstractList
java.util.ArrayList

总结：我们发现，第二种我们可以获取到list是一个什么样的类型。而第二种就是声明了一个匿名内部类。但是为什么匿名内部类就能获取到lis泛型参数的类型呢？其实类型擦除并不是真的将全部的类型信息都擦除了，还是会将类型信息放在对于的class的常量池中的。

所以我们可以尝试设计出获取所有类型信息的泛型类。

open class GenericsToken {
    var type: Type = Any::class.java
    init {
        val superClass = this.javaClass.gnericSuperclass
        type = superClass as ParameterizedType).getActualTypeArguments()[0]
    }
}


fun test() {
    val gt = object : GenericsToken>(){}
    println(gt.type)
}

//打印结果
java.util.Map

总结：匿名内部类在初始化的时候，绑定父类或父类接口的相应信息，这样可以通过获取父类或父借口的父接口的泛型类型信息来获取我们想要的泛型类型。其实常用的Gson框架也是采用这样的方式获取的。

val json = new Json("...")
val type = object : TypeToken>(){}.type
val stringList = Gson().fromJson>(json.type)

【2.3.2】使用 Kotlin 的 reified 关键字获取泛型类型

我们知道Kotlin的内联函数是在编译的时候，编译器把内联函数的字节码直接插入到调用的地方，所以参数类型也会被插入到字节码中。而在内联函数中获取泛型的参数类型也非常简单，只需要加上reified关键字就可以。

inline fun  getType(): T {
    return T::class.java
}

三、类型约束。

我们前面说的泛型时，讲到其中一个特性就是类型安全，其实也就是说泛型本身带有类型的约束力。那么这里讲的类型约束是什么意思呢。其实就是对泛型的约束。在Java中看我们会看到如下代码：

class Test {
...    
}

通过在T后面加了extends B约束了这个泛型必须是B的子类。那么在Kotlin中，继承是用：表示的，所以Kotlin的泛型约束如下：

class Test{
    
}

但是，如果我们需要多个约束呢？在Kotlin中可以使用 where 关键字来实现这个需求如下：

class Test where T: A, T: B{

}

利用where关键字，我们可以约束泛型T必须是A和B的子类。

四、泛型的变形：协变和逆变

【4.1】协变

讲义：如果类型A是类型B的子类型，那么Generic也是Generic的子类，这就是协变。
在kotlin中，我们要实现这种关系，可以通过在泛型类或者泛型方法的泛型参数前面加 out 关键字。如下：

//定义实体类关系
open class Flower
class WhiteFlower: Flower(){}
class ReaFlower: Flower(){}

//生产者
interface Product {
     fun produce(): T
}

class WhiteFlowerProduct {
    //将泛型类型作为返回
    override fun produce(): WhiteFlower {
       return WhileFlower();
    }
}

//如下编译通过
val product: Product = WhiteFLowerProduct()

总结：可以看到，WhiteFLowerProduct()可以赋值给Product 类型变量，就是因为通过out指明了协变关系。而且我们也看到，泛型类型做为返回类型，被生产出来。那么如果我们添加一个泛型类型的对象呢？如下：

interface Product {
    fun produce(): T
    //编译器报错
    fun add(t: T)
}

class WhiteFlowerProduct {
    //将泛型类型作为返回
    override fun produce(): WhiteFlower {
       return WhileFlower();
    }
    
    override fun add(flower: WhiteFlower){
       return WhileFlower();
    }
}

结果是编译器报错：Type parameter T is declare as 'out' but occurs in 'in' position in type T。翻译过来就是被声明为out的类型T不能出现在输入的位置。其实我们通过'out'关键字也可以知道，被其修饰的泛型只能作为生产者输出，而不能作为消费者输入。所以'out'修饰的泛型常常作为方法的返回而使用。这就是协变带来的限制。那么协变为什么不能输入呢。我们可以采用反证法来理解：假如可以添加，那么会发生什么事？

val flowerProduct: Product = WhiteFLowerProduct()
//编译不出错，但是运行时会出现类型不兼容错误。
flowerProduct.add(ReaFlower())

其在Java中，相对应的泛型协变我们是这样定义的： 但是这一不便理解的泛型协变定义在Kotlin上被改进成用out关键字，更加能体现其协变只读不可写的特性。

【4.2】逆变

定义：如果类型A是类型B的子类型，反过来Generic是Generic的子类型，我们称这种关系为逆变。在Kotlin中，我们用'in'关键字来声明逆变泛型。如下例子：

val numberComparator = Comparator {
    n1, n2 -> n1.toDouble.compareTo(n2.toDouble())
}

val daoubleList = mutableListOf(2.0, 3.0)
//针对Double数据类型，我们使用Number类型的Comparator
doubleList.sortWith(numberComparator)

val intList = mutableListof(1, 2)
//针对Int数据类型，我们仍然使用Number 类型的Comparator
intList.sortWith(numberComparator)

//可以看到这里对泛型T，使用了in关键字。
public fun  MutableList.sortWith(comparator: Comparator): Unit {
    if (size > 1) java.util.Collections.sort(this, comparator)
}

通过如上代码我们知道，本来Double和Int是Number的子类，通过in修饰符后，Comparator成为了Comparator 和 Comparator 的子类，所以可以将Comparator赋值给Comparator和Comparator。从而不用在专门根据不同的数据类型，定义不同的DoubleComparator、IntComparatort等。
同样的，通过它的名字'in'也可以知道。in修饰的泛型只能作为输入类型，而不能作为返回类型。在Java中它对应着。

【4.3】总结

是	协变	逆变	不变
Kotlin	实现方式： 只能作为消费者，只能读取不能写入	实现方式 只能添加，读取受限	实现方式：, 可读可写
Java	实现方式： 只能作为消费者，只能读取不能写入	实现方式 只能添加，读取受限	实现方式：, 可读可写

鸣谢

小弟早期阅读《Kotlin核心编程》时，一直觉得书中对Kotlin的泛型讲解得非常好，所以一直有想法写一篇相关的博文，也算是读书笔记了。文中有不尽之处，欢迎留言指出。谢谢！