Kotlin笔记12-Java和Kotlin中的范型对比（一）

Kotlin中的范型和Java中的比较相似，可以参考我的关于介绍Java范型的文章 ：

Java范型那些事（一）

Java范型那些事（二）

Java范型那些事（三）

Java范型那些事（四）

在上述博文中，讲述了为什么Java要在1.5版本中引入范型，以及一些有关Java范型的基本知识点。

---

如果把一个对象分为声明、使用两部分的话。泛型主要是侧重于类型的声明的代码复用，通配符则侧重于使用上的代码复用。泛型用于定义内部数据类型的参数化，通配符则用于定义使用的对象类型的参数化。

使用泛型、通配符提高了代码的复用性。同时对象的类型得到了类型安全的检查，减少了类型转换过程中的错误。

---

 范型和数组的型变

 Java中数组是协变的

下面的代码是可以正确编译运行的：

        Integer[] ints = new Integer[3];
        ints[0] = 0;
        ints[1] = 1;
        ints[2] = 2;
        Number[] numbers = new Number[3];
        numbers = ints;
        for (Number n : numbers) {
            System.out.println(n);
        }

在Java中，因为 Integer 是 Number 的子类型，数组类型 Integer[] 也是 Number[] 的子类型，因此在任何需要 Number[] 值的地方都可以提供一个 Integer[] 值。

Java对List泛型不是协变的

也就是说， List 不是 List 的子类型，试图在要求 List 的位置提供 List 是一个类型错误。下面的代码，编译器是会直接报错的：

就算我们使用通配符，这样写：

 仍然是报错的。

为什么Number的对象可以由Integer实例化，而ArrayList的对象却不能由ArrayList实例化？list中的声明其元素是Number或Number的派生类，为什么不能add Integer?为了解决这些问题，需要了解Java中的逆变和协变以及泛型中通配符用法。

逆变、协变和不变都是用来描述类型转换(type transformation)后的继承关系，其定义：如果A、B表示类型，f(⋅)表示类型转换，≤表示继承关系(比如，A≤B表示A是由B派生出来的子类)

•    当A≤B时有f(A)≤f(B)成立，则f(⋅)是协变（covariant）的
•    当A≤B时有f(B)≤f(A)成立，则f(⋅)是逆变（contravariant）的
•    当A≤B时上述两个式子均不成立，即f(A)与f(B)相互之间没有继承关系，f(⋅)是不变（invariant）的

协变和逆协变都是类型安全的。

 

Kotlin的数组不是协变的

abstract class Animal(val size: Int)
class Dog(val cuteness: Int): Animal(100)
class Cat(val terrorFactor: Int): Animal(1)

以下数组编译报错：

val dogArr: Array = arrayOf(Dog(1), Dog(2))
val animalArr: Array = dogArr

和Java的普通对象一样，以下代码可以编译通过：

val dog: Dog = Dog(10)
var animal: Animal = dog

而Kotlin中以如下方式定义一个范型类，然后使用时也会编译报错：

class ReadableList{

}

val dogReadable: ReadableList = ReadableList()
 //提示报错，需要ReadableList，但却传了ReadableList
val animalReadable: ReadableList = dogReadable

Kotlin对List泛型是协变的

即以下代码可以编译通过

val dogList: List = listOf(Dog(10), Dog(20))
playAnimal(dogList)

fun playAnimal(animalList: List) {
    ...
}

---

如何使Java和Kotlin添加协变和逆变支持

Java中泛型是不变的，可有时需要实现逆变与协变，怎么办呢？这时就需要使用我们之前讲的通配符? 。

在Java和Kotlin中可以通过一定的方式对默认不支持协变的参数类型添加支持。 但是Java和Kotlin这两种语言处理的方式不同：

•    Java : use-site variance(使用端型变)
•    Kotlin : declaration-site variance(声明端型变)

可以看出Java使用的是使用端型变，而Kotlin使用的是声明端型变。这两者有什么区别呢？

个人理解就是使用端型变(use-site variance)就是在具体使用(初始化)某一个Class的对象时进行协变。

Java 通过实现了泛型的协变

List list = new ArrayList<>();  

这里的? extends Number表示的是Number类或其子类，我们简记为C。

这里C <= Number，这个关系成立：List <= List< Number >。即有：

List list1 = new ArrayList();  
List list2 = new ArrayList();  

另外一个例子，具体如下代码所示：

List catList = new ArrayList<>();
List animalList = catList;

可以看到，在我们声明animalList时，对泛型进行了一点修改，使用? extends Animal进行修饰之后，以上代码就可以成功编译并运行了。甚至于我们可以定义一个方法来接受这种参数类型，如下所示：

List cats = new ArrayList<>();
playAnimal(cats);

public static void playAnimal(List animal) {
    ...
}

编译可以顺利通过， 这样我们的代码可扩展性会更高！

⚠️注意：此时除了null之外，不能往animalList中添加任何Animal子类的对象，即以下代码会报错：

如果可以添加的话，List里面将会持有各种Number子类型的对象（Byte，Integer，Float，Double等等）。Java为了保护其类型一致，禁止向List添加任意对象，不过可以添加null。

Java 通过实现了泛型的逆变

List list = new ArrayList<>();  

? super Number 通配符则表示的类型下界为Number。即这里的父类型F是? super Number, 子类型C是Number。即当F <=C , 有f(C) <= f(F) ， 这就是逆变。代码示例：

List list3 = new ArrayList();  
List list4 = new ArrayList