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<Fish> fishList = new ArrayList<>();
fishList.add(new Fish());
List<Animal> 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<Fish> = ArrayList()
fishList.add(Fish())
val catList: MutableList<Cat> = ArrayList()
catList.add(Cat())
val animals1: MutableList<out Animal> = fishList
val animals2: MutableList<out Animal> = catList
animals2.add(Fish()) // 报错
val animal1 = animals1[0]
val animal2 = animals2[0]
animal1.eat()
animal2.eat()
}
fun superFun() {
val fishList: MutableList<Fish> = ArrayList()
fishList.add(Fish())
val animalList: MutableList<Animal> = ArrayList()
animalList.add(Cat())
animalList.add(Fish())
val fish1: MutableList<in Fish> = fishList
val fish2: MutableList<in Fish> = animalList
fish1.add(Fish())
val fish: Fish = fish2[0] //报错
}
可以看到在 `kotlin` 代码中除了将 `? extends` 替换为了 `out`,将 `? super` 替换为了 `in`,其他地方并没有发生变化,而产生的结果是一样的。那在类或接口的定义处声明 `in、out` 的作用是什么呢。
假设有一个泛型接口 `Source<T>`,该接口中不存在任何以 `T` 作为参数的方法,只是方法返回 `T` 类型值:
// Java
interface Source {
T nextT();
}
那么,在 `Source <Object>` 类型的变量中存储 `Source <String>` 实例的引用是极为安全的——没有消费者-方法可以调用。但是 `Java` 并不知道这一点,并且仍然禁止这样操作:
// Java
void demo(Source strs) {
Source objects = strs; // !!!在 Java 中不允许
// ……
}
为了修正这一点,我们必须声明对象的类型为 `Source<? extends Object>`,但这样的方式很复杂。而在 `kotlin` 中有一种简单的方式向编译器解释这种情况。我们可以标注 `Source` 的类型参数 `T` 来确保它仅从 `Source<T>` 成员中返回(生产),并从不被消费。为此我们使用 `out` 修饰符修饰泛型 `T`:
interface Source {
fun nextT(): T
}
fun demo(strs: Source) {
val objects: Source<Any> = 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` 的输入位置。