逆变与协变用来描述类型转换后的继承关系，其定义：如果 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 animals1 = fishList;

    List 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 fish1 = fishList;

    List 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