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 作为参数的方法，只是方法返回 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 = 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！

}

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）

最后

Android学习是一条漫长的道路，我们要学习的东西不仅仅只有表面的 技术，还要深入底层，弄明白下面的 原理，只有这样，我们才能够提高自己的竞争力，在当今这个竞争激烈的世界里立足。

人生不可能一帆风顺，有高峰自然有低谷，要相信，那些打不倒我们的，终将使我们更强大，要做自己的摆渡人。

资源持续更新中，欢迎大家一起学习和探讨。

《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》，点击传送门即可获取！

最后

Android学习是一条漫长的道路，我们要学习的东西不仅仅只有表面的 技术，还要深入底层，弄明白下面的 原理，只有这样，我们才能够提高自己的竞争力，在当今这个竞争激烈的世界里立足。

人生不可能一帆风顺，有高峰自然有低谷，要相信，那些打不倒我们的，终将使我们更强大，要做自己的摆渡人。

资源持续更新中，欢迎大家一起学习和探讨。

《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》，点击传送门即可获取！