kotlin 协变、逆变 - 猫和鱼的故事
网上找的一段协变、逆变比较正式的定义：
逆变与协变用来描述类型转换后的继承关系，其定义：如果
A、B表示类型，f(⋅)表示类型转换，≦表示继承关系（比如，A≦B表示A是由B派生出来的子类）： 当A ≦ B时,如果有f(A) ≦ f(B),那么f是协变的； 当A ≦ B时,如果有f(B) ≦ f(A),那么f是逆变的； 如果上面两种关系都不成立，即(A)与f(B)相互之间没有继承关系，则叫做不变的。
java 中可以通过如下泛型通配符以支持协变和逆变：
? extends来使泛型支持协变。修饰的泛型集合只能读取不能修改，这里的修改仅指对泛型集合添加元素，如果是remove(int index)以及clear当然是可以的。? super来使泛型支持逆变。修饰的泛型集合只能修改不能读取，这里说的不能读取是指不能按照泛型类型读取，你如果按照Object读出来再强转当然也是可以的。
以动物举例，看代码。
abstract class Animal {
void eat() {
System.out.println("我是" + myName() + ", 我最喜欢吃" + myFavoriteFood());
}
abstract String myName();
abstract String myFavoriteFood();
}
class Fish extends Animal {
@Override
String myName() {
return "鱼";
}
@Override
String myFavoriteFood() {
return "虾米";
}
}
class Cat extends Animal {
@Override
String myName() {
return "猫";
}
@Override
String myFavoriteFood() {
return "小鱼干";
}
}
public static void extendsFun() {
List fishList = new ArrayList<>();
fishList.add(new Fish());
List catList = new ArrayList<>();
catList.add(new Cat());
List<? extends Animal> animals1 = fishList;
List<? extends Animal> animals2 = catList;
animals2.add(new Fish()); // 报错
Animal animal1 = animals1.get(0);
Animal animal2 = animals2.get(0);
animal1.eat();
animal2.eat();
}
//输出结果：
我是鱼, 我最喜欢吃虾米
我是猫, 我最喜欢吃小鱼干
协变就好比有多个集合，每个集合存储的是某中特定动物（extends Animal），但是不告诉你那个集合里存储的是鱼，哪个是猫。所以你虽然可以从任意一个集合中读取一个动物信息，没有问题，但是你没办法将一条鱼的信息存储到鱼的集合里，因为仅从变量 animals1、animals2 的类型声明上来看你不知道哪个集合里存储的是鱼，哪个集合里是猫。 假如报错的代码不报错了，那不就说明把一条鱼塞进了一堆猫里，这属于给猫加菜啊，所以肯定是不行的。? extends 类型通配符所表达的协变就是这个意思。
那逆变是什么意思呢？还是以上面的动物举例：
public static void superFun() {
List fishList = new ArrayList<>();
fishList.add(new Fish());
List animalList = new ArrayList<>();
animalList.add(new Cat());
animalList.add(new Fish());
List<? super Fish> fish1 = fishList;
List<? super Fish> fish2 = animalList;
fish1.add(new Fish());
Fish fish = fish2.get(0); //报错
}
从变量 fish1、fish2 的类型声明上只能知道里面存储的都是鱼的父类，如果这里也不报错的话可就从 fish2 的集合里拿出一只猫赋值给一条鱼了，这属于谋杀亲鱼。所以肯定也是不行。? super 类型通配符所表达的逆变就是这个意思。
kotlin 中对于协变和逆变也提供了两个修饰符：
out：声明协变；in：声明逆变。
它们有两种使用方式：
- 第一种：和
java一样在使用处声明； - 第二种：在类或接口的定义处声明。
当和 java 一样在使用处声明时，将上面 java 示例转换为 kotlin：
fun extendsFun() {
val fishList: MutableList = ArrayList()
fishList.add(Fish())
val catList: MutableList = ArrayList()
catList.add(Cat())
val animals1: MutableList = fishList
val animals2: MutableList = catList
animals2.add(Fish()) // 报错
val animal1 = animals1[0]
val animal2 = animals2[0]
animal1.eat()
animal2.eat()
}
fun superFun() {
val fishList: MutableList = ArrayList()
fishList.add(Fish())
val animalList: MutableList = ArrayList()
animalList.add(Cat())
animalList.add(Fish())
val fish1: MutableList = fishList
val fish2: MutableList = animalList
fish1.add(Fish())
val fish: Fish = fish2[0] //报错
}
可以看到在 kotlin 代码中除了将 ? extends 替换为了 out，将 ? super 替换为了 in，其他地方并没有发生变化，而产生的结果是一样的。那在类或接口的定义处声明 in、out 的作用是什么呢。
假设有一个泛型接口 Source，该接口中不存在任何以 T 作为参数的方法，只是方法返回 T 类型值：
// Java
interface Source {
T nextT();
}
那么，在 Source 类型的变量中存储 Source 实例的引用是极为安全的——没有消费者-方法可以调用。但是 Java 并不知道这一点，并且仍然禁止这样操作：
// Java
void demo(Source strs) {
Source objects = strs; // ！！！在 Java 中不允许
// ……
}
为了修正这一点，我们必须声明对象的类型为 Source<? extends Object>，但这样的方式很复杂。而在 kotlin 中有一种简单的方式向编译器解释这种情况。我们可以标注 Source 的类型参数 T 来确保它仅从 Source 成员中返回（生产），并从不被消费。为此我们使用 out 修饰符修饰泛型 T：
interface Source {
fun nextT(): T
}
fun demo(strs: Source) {
val objects: Source = strs // 这个没问题，因为 T 是一个 out-参数
// ……
}
还记得开篇协变的定义吗？
当
A ≦ B时,如果有f(A) ≦ f(B),那么f是协变的； 当A ≦ B时,如果有f(B) ≦ f(A),那么f是逆变的；
也就是说：
当一个类
C的类型参数T被声明为out时，那么就意味着类C在参数T上是协变的；参数T只能出现在类C的输出位置，不能出现在类C的输入位置。
同样的，对于 in 修饰符来说
当一个类
C的类型参数T被声明为in时，那么就意味着类C在参数T上是逆变的；参数T只能出现在类C的输如位置，不能出现在类C的输出位置。
interface Comparable {
operator fun compareTo(other: T): Int
}
fun demo(x: Comparable) {
x.compareTo(1.0) // 1.0 拥有类型 Double，它是 Number 的子类型
// 因此，我们可以将 x 赋给类型为 Comparable 的变量
val y: Comparable = x // OK！
}
总结如下表：
