kotlin 协变、逆变 - 猫和鱼的故事，Android程序员

 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<Fish> fishList = new ArrayList<>();

fishList.add(new Fish());

List<Cat> 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<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 {