一篇文章教你搞清楚——Kotlin-进阶---不变型、协变、逆变

引入泛型之后，子类型的概念变得复杂起来，好不容易用刚学会的泛型定义了方法，用起来却各种障碍。且听我把概念敲碎了再拼起来，娓娓道来。

子类型

---

任何时候，如果要使用 类型A 的值，都能用 类型B 的值作为替换（当做 A 的值），称 B 是 A 的子类型。

从定义中可以看出，任何类型也是它自身的子类型。
把定义说的通俗一点就是“小范围的类可以替换大范围的类”。Int是Number的子类，是因为Int所代表的数的集合范围是Number所代表的子集。
“一个类是否是另一个的子类型”？这个问题对于编译器来说很重要，因为每次给变量赋值或为函数传递实参时都要做这个检查。只有值的类型是变量的子类型时，才允许变量存储该值。

泛型中的子类型

---

引入泛型之前，子类型的定义很明确，想要判断一个类是否是另一个的子类型也颇为直观，比如String是CharSequence的子类。
一旦引入泛型后，就变得复杂，比如：List是List的子类吗？换句话说，所有使用List的地方都能用List代替吗？其实还蛮难一下子做出判断的。
为了解决这个难题，需要在原始定义的基础上推导出两个推论：

1.子类型方法接收参数的范围 不得小于 父类型方法

举一个反例：“美团1.0”声称接受微信和支付宝两种支付方式，它的子类型“美团2.0”声称只能接受微信支付，若用“美团2.0”替换“美团1.0”，则原先和“美团1.0”交互的代码可能报错，因为他们还是会传入支付宝，但“美团2.0”处理不了。为了让“美团2.0”替换“1.0”，它必须至少支持微信和支付宝两种方式，新增其他的支付方式也没什么不可以。

2.子类型方法返回值的范围 不得大于 父类型方法

举一个反例：“商家1.0”宣传画报上包含盖浇饭和汤，所以我准备了筷子和汤勺。它的子类型“商家2.0”突然新增了苹果，但我并没有准备刨子，就吃不了，报错了。所以商家返回的东西不能变多，否则我无法应付。

如果List要成为List的子类就必须满足下面两个条件：

1.List中方法接收参数的范围 不得小于 List的方法
2.List中方法返回值的范围 不得大于 List的方法

List定义如下：

// List带泛型的定义
public interface List extends Collection {
boolean add(E e);
E get(int index);
}

// List定义如下:
public interface List extends Collection {
boolean add(String e);
String get(int index);
}

// List定义如下:
public interface List extends Collection {
boolean add(CharSequence e);
CharSequence get(int index);
}

虽然String get(int index);返回值的范围比CharSequence get(int index);小，满足了第二个条件。

但boolean add(String e);接收参数的范围明显比boolean add(CharSequence e);要小，不满足第一个条件。

所以List中不是List的子类型。换句话说，把程序中的List都替换成List是不安全的，因为可能会存在这样的代码:

val spannable = Spannable()
val list: List = mutableListOf()
list.add(spannable)

如果把这里的List换成List，编译器就会报错。因为boolean add(String e);只会处理String类型的实参，Spannable超出了这个范围。

不变型

---

把上面的例子表达成更抽象的定义如下：

假设 泛型 类A 包含 类型参数T，即class A，而Type1是Type2的子类，如果A和A不存在父子关系，则称 类A 在类型参数上是不变型的。

Kotlin 和 Java 中的类都是不变型的。

这样会造成一些限制，辛辛苦苦抽象了一个方法，它接收一个List作为参数：handle(chars: List)，想当然地把List传递进入时，编译器会报错。。。难道需要为List重新定义一个相同的方法吗？

协变

---

不变型描述的是泛型类之间没有子类型关系，泛型类之间还有一种子类型关系叫协变。

协变的意思是：类与其类型参数的抽象程度具有相同的变化方向。

(试图总结某个抽象概念时，总会说出一些让人听不懂话。。。)

换句话说：当类型参数变得更具体时，类也变得更具体。当类型参数变得更抽象时，类也变得更抽象。

比如，从List到List，类型参数从String变为更抽象的CharSequence，如果List到List的变化方向也是更抽象（前者是后者的子类），就称List在类型参数T上是协变的。（显然这个例子不是协变的而是不变型的）

如果一个泛型类是协变的，就意味着它在类的层面保留了类型参数的子类型关系

Kotlin 中，声明类在类型参数上是协变的，需要添加out保留字：

class MyList{ … }

虽然将泛型类声明为协变可以让其子类型化关系更符合直觉，但这需要付出代价：

class MyList {
fun set(item: T) {}//报错: Type parameter is declare as “out” but occur at “in” position in type T
fun get(): T {…}
}

• 若T出现在方法的参数位，称set(item: T)消费类型为T的值。

• 若T出现在返回值位时，称get(): T生产类型为T的值。

当T被out修饰后，它只能出现在返回值位，即它只能被泛型类生产而不能被消费。
所以out会产生两个效果：

1.它保留了泛型类的子类型化。
2.它限制了类型参数只能出现在返回值位。

这两点是相辅相成的：正因为它限制了类型参数不能出现在参数位，所以子类型化得以保留。正因为它保留了子类型化，所以类型参数只能出现在返回值位。

假设类型参数出现在了参数位，就会出现在这样的情况：

class MyList {
fun set(itme: String)
fun get(): String
}

class MyList {
fun set(itme: CharSequence)
fun get(): CharSequence
}
复制代码
因为fun set(itme: String)可以接收的参数范围比fun set(itme: CharSequence)小，不符合第一条退推论，所以MyList不是MyList的子类型。
而添加了out之后，相当于告诉编译器把出错的方法删掉以保留子类型化：
class MyList {
fun get(): T {…}
}

class MyList {
fun get(): String
}

class MyList {
fun get(): CharSequence
}

此时fun get(): String返回值的范围比fun get(): CharSequence小，符合第二条推论，所以MyList是MyList的子类型。

逆变

---

除了不变型、协变，泛型类之间还有一种子类型关系：逆变。

逆变的意思是：类与其类型参数的抽象程度具有相反的变化方向。

换句话说：当类型参数变得更具体时，类却变得更抽象。当类型参数变得更抽象时，类却变得更具体。
逆变有一点反直觉，它想实现的效果是：List成为List是的子类型。

如果一个泛型类是逆变的，就意味着它在类的层面反转了类型参数的子类型关系

Kotlin 中，声明类在类型参数上是逆变的，需要添加in保留字：

class MyList{ … }

同样地，这需要付出代价：

class MyList {
fun set(item: T) {}
fun get(): T {…}//报错: Type parameter is declare as “in” but occur at “out” position in type T
}

当T被in修饰后，它只能出现在参数位，即它只能被泛型类消费而不能被生产。
由此可见：

out和int不仅限定了参数可以出现的位置，还限定了什么类可以成为子类型。

类型投影

---

生活中的投影，是把一个三维物体变成二维物体，投影看上去还是那个物体只是降了一维。
程序中的类型投影也是类似的意思：

将类型投影意味着保留该类型的有些能力，去掉另一些能力。通过类型投影可以动态地改变泛型类的子类型关系。

类型投影通常应用于将不变型的泛型类动态地转换成逆变或协变。
比如，MutableList就是不变型的：

public interface MutableList : List, MutableCollection {
// 类型参数出现在 out 位置
public fun removeAt(index: Int): E
// 类型参数出现在 in 位置
public fun add(index: Int, element: E): Unit
…
}

MutableList是不变型，所以泛型参数可随意出现在in或out位置。

但不变型有时候会缩小方法的适用范围，比如：

fun copy(source: MutableList, destination: MutableList){
for (item in source){
destination.add(item)
}
}

这是一个拷贝集合的方法，引入泛型是为了避免为每一种具体的类型都重新定义一遍方法。现在这个方法可以在任何数据类型相同的两个列表见拷贝内容。

但如果我想把一个字符串集合拷贝到可以包含任意对象的集合中怎么办？

val strings = mutableListOf( “a”, “b”, “c” )
val anys = mutableListOf()

copy( strings, anys )// 报错

因为copy()的定义要求源和目的集合具有相同的类型。

为了让copy()方法能适用于这种情况，可以这样改写：

fun <R: T, T> copy(source: MutableList, destination: MutableList){
for (item in source){
destination.add(item)
}
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

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

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

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

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

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

总结

算法知识点繁多，企业考察的题目千变万化，面对越来越近的“金九银十”，我给大家准备好了一套比较完善的学习方法，希望能帮助大家在有限的时间里尽可能系统快速的恶补算法，通过高效的学习来提高大家面试中算法模块的通过率。

这一套学习资料既有文字档也有视频，里面不仅仅有关键知识点的整理，还有案例的算法相关部分的讲解，可以帮助大家更好更全面的进行学习，二者搭配起来学习效果会更好。

部分资料展示：

有了这套学习资料，坚持刷题一周，你就会发现自己的算法知识体系有明显的完善，离大厂Offer的距离更加近。

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

链图片转存中…(img-BKGY1Qxc-1713496858022)]
[外链图片转存中…(img-QgTxpbUX-1713496858023)]

有了这套学习资料，坚持刷题一周，你就会发现自己的算法知识体系有明显的完善，离大厂Offer的距离更加近。

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！