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

1、泛型的必要性

【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<A> 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、泛型的实现：类型擦除

【2.1】泛型的实际实现

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

//没有加泛型
ArrayList list = new ArrayList();
//加了泛型
ArrayList<A> AList = new ArrayList();
复制代码

字节码：

//ArrayList list = new ArrayList();
0:  new               #2
3:  dup
4:  invokespecial     #3
7:  astore+1
//ArrayList<A> 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<T>(val data: T, val clazz: Class<T>) {

    fun getType() {
        println(clazz)
    }

}

复制代码

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

//编译不一样过，报错
Class clazz = ArrayList<String>.class
复制代码

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

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

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

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

//打印：
java.util.AbstractList<E>
java.util.ArrayList<java.lang.String>
复制代码

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

因此咱们能够尝试设计出获取全部类型信息的泛型类。

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


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

//打印结果
java.util.Map<java.lang.String, ? extends java.lang.String>
复制代码

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

val json = new Json("...")
val type = object : TypeToken<List<String>>(){}.type
val stringList = Gson().fromJson<List<String>>(json.type)
复制代码

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

咱们知道Kotlin的内联函数是在编译的时候，编译器把内联函数的字节码直接插入到调用的地方，因此参数类型也会被插入到字节码中。而在内联函数中获取泛型的参数类型也很是简单，只须要加上reified关键字就能够。

inline fun <reified T> getType(): T {
    return T::class.java
}
复制代码

3、类型约束。

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

class Test<T extends B> {
...    
}
复制代码

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

class Test<T: B>{
    
}
复制代码

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

class Test<T> where T: A, T: B{

}
复制代码

利用where关键字，咱们能够约束泛型T必须是A和B的子类。

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

【4.1】协变

讲义：若是类型A是类型B的子类型，那么Generic<A>也是Generic<B>的子类，这就是协变。
在kotlin中，咱们要实现这种关系，能够经过在泛型类或者泛型方法的泛型参数前面加 out 关键字。以下：

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

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

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

//以下编译经过
val product: Product<Flower> = WhiteFLowerProduct()
复制代码

总结：能够看到，WhiteFLowerProduct()能够赋值给Product 类型变量，就是由于经过out指明了协变关系。并且咱们也看到，泛型类型作为返回类型，被生产出来。那么若是咱们添加一个泛型类型的对象呢？以下：

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

class WhiteFlowerProduct<WhiteFlower> {
    //将泛型类型做为返回
    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<Flower> = WhiteFLowerProduct()
//编译不出错，可是运行时会出现类型不兼容错误。
flowerProduct.add(ReaFlower())
复制代码

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

【4.2】逆变

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

val numberComparator = Comparator<Number> {
    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 <T> MutableList<T>.sortWith(comparator: Comparator<in T>): 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中它对应着<? super T>。

【4.3】总结

是	协变	逆变	不变
Kotlin	实现方式： 只能做为消费者，只能读取不能写入	实现方式 只能添加，读取受限	实现方式：, 可读可写
Java	实现方式：<? extends T> 只能做为消费者，只能读取不能写入	实现方式<? super T> 只能添加，读取受限	实现方式：, 可读可写

鸣谢

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