引入泛型之后，子类型的概念变得复杂，好不容易用刚学会的泛型定义了方法，用起来编译器却各种障碍。且听我把概念敲碎了再拼起来，娓娓道来。 ## 子类型 > 任何时候，如果要使用类型A 的值，都能用类型B 的值作为替换（当做 A 的值），称 B 是 A 的**子类型**。从定义中可以看出，任何类型也是它自身的子类型。把定义说的通俗一点就是 **“小范围的类可以替换大范围的类”** 。`Int`是`Number`的子类，是因为`Int`所代表的数的集合范围是`Number`所代表的子集。 “一个类是否是另一个的子类型”？这个问题对于编译器来说很重要，因为每次给变量赋值或为函数传递实参时都要做这个检查。只有值的类型是变量的子类型时，才允许变量存储该值。 ## 泛型中的子类型引入泛型之前，子类型的定义很明确，想要判断一个类是否是另一个的子类型也颇为直观，比如`String`是`CharSequence`的子类。一旦引入泛型后，就变得复杂，比如：`List`是`List`的子类吗？换句话说，所有使用`List`的地方都能用`List`代替吗？其实还蛮难一下子做出判断的。为了解决这个难题，需要在原始定义的基础上推导出两个推论： > 1. 子类型方法接收参数的范围不得小于父类型方法 > 2. 子类型方法返回值的范围不得大于父类型方法只有满足了这两个条件，才能无副作用地将程序中父类对象都替换成子类对象（无副作用即是程序符合原有的逻辑）。如果`List`要成为`List`的子类就必须满足下面两个条件： 1. `List`中方法接收参数的范围不得小于 `List`的方法 2. `List`中方法返回值的范围不得大于 `List`的方法 `List`定义如下： ```java // 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`是不安全的，因为可能会存在这样的代码: ```kotlin 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`保留字： ```kotlin class MyList{ ... } ``` 虽然将泛型类声明为协变可以让其子类型化关系更符合直觉，但这需要付出代价： ```kotlin 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. 它限制了类型参数只能出现在返回值位。这两点是相辅相成的：正因为它限制了类型参数不能出现在参数位，所以子类型化得以保留。正因为它保留了子类型化，所以类型参数只能出现在返回值位。假设类型参数出现在了参数位，就会出现在这样的情况： ```kotlin 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`之后，相当于告诉编译器把出错的方法删掉以保留子类型化： ```kotlin 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`保留字： ```kotlin class MyList{ ... } ``` 同样地，这需要付出代价： ```kotlin 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`不仅限定了参数可以出现的位置，还限定了什么类可以成为子类型。 ## PECS 原则 & POCI 原则 **PECS = producer extends，consumer super**，即如果泛型类生产泛型对象，则使用``通配符表示协变。如果泛型类消费泛型对象，则使用``通配符表示逆变。 Kotlin 中使用更简单的`out`, `in`表达协变和逆变。所以 PECS 原则在 Kotlin 中可以表述为**POCI 原则** ## 类型投影生活中的投影，是把一个三维物体变成二维物体，投影看上去还是那个物体只是降了一维。程序中的**类型投影**也是类似的意思： >将类型投影意味着保留该类型的有些能力，去掉另一些能力。通过类型投影可以动态地改变泛型类的子类型关系。类型投影通常应用于将**不变型**的泛型类动态地转换成**逆变**或**协变**。比如，`MutableList`就是不变型的： ```kotlin public interface MutableList : List, MutableCollection { // 类型参数出现在 out 位置 public fun removeAt(index: Int): E // 类型参数出现在 in 位置 public fun add(index: Int, element: E): Unit ... } ``` `MutableList`是不变型，所以泛型参数可随意出现在`in`或`out`位置。但不变型有时候会缩小方法的适用范围，比如： ```kotlin fun copy(source: MutableList, destination: MutableList){ for (item in source){ destination.add(item) } } ``` 这是一个拷贝集合的方法，引入泛型是为了避免为每一种具体的类型都重新定义一遍方法。现在这个方法可以在任何数据类型相同的两个列表见拷贝内容。但如果我想把一个字符串集合拷贝到可以包含任意对象的集合中怎么办？ ```kotlin val strings = mutableListOf( "a", "b", "c" ) val anys = mutableListOf() copy( strings, anys )// 报错 ``` 因为`copy()`的定义要求源和目的集合具有相同的类型。为了让`copy()`方法能适用于这种情况，可以这样改写： ```kotlin fun copy(source: MutableList, destination: MutableList){ for (item in source){ destination.add(item) } } ``` 引入第二个泛型`R`，它是`T`的子类型，并指定它为源集合类型参数。这个改动一下子扩展了`source`参数接受实参类型的范围，原本它只能和`destination`使用同样的类型，现在它可以使用所有`destination`的子类型。运用**变型**可以简化这个改动： ```kotlin fun copy(source: MutableList, destination: MutableList){ for (item in source){ destination.add(item) } } ``` `source`参数声明的地方，发生了**out 类型投影**，投影去掉了`MutableList`中所有消费类型参数的方法，保留了所有生产类型参数的方法。虽然`source`参数丧失了部分能力，但牺牲总是有回报的，`source`所能接受实参的类型范围被扩展了。（碰巧，`copy()`方法体中也不需要`source`丧失的那部分能力。） `MutableList`和`MutableList`的区别如下： ```kotlin public interface MutableList { // 类型参数出现在 out 位置的方法保持原样 public fun removeAt(index: Int): T // 类型参数出现在 in 位置的方法被改写 public fun add(index: Int, element: Nothing): Unit ... } ``` `out`保留字命令编译器去改写泛型类中所有消费类型参数的方法，将`in`位置的参数类型改成`Nothing`。 `Nothing`是所有类的子类，为啥要这样改呢？**因为想让`MutableList`成为`MutableList`的子类型**。回忆一下子类型的 2 个推论： > 1. 子类型方法接收的参数范围不得小于父类型方法 > 2. 子类型方法返回的结果的范围不得大于父类型方法当没有`out`投影时，`public fun add(index: Int, element: String): Unit`接收参数的范围小于`public fun add(index: Int, element: CharSequence): Unit`接收参数的范围，它不符合第一条规则，所以`MutableList`不是`Group`的子类型。换成`public fun add(index: Int, element: Nothing): Unit`后，情况就大不一样了。`Nothing`是所有类的子类，它也不能被实例化，并且没有子类型。换句话说如果一个方法接收`Nothing`类型的参数，意味着没有任何类型可以作为参数传入（唯一可以传入的 Nothing 却不能实例化）。这样的话`public fun add(index: Int, element: String): Unit`接收参数的范围就比“什么也不能接收”大了（好歹它能接收 String 类型）。类似地，`in`保留字命令编译器去改写泛型类中所有生产类型参数的方法，将`out`位置的参数改成`Any?`。 ```kotlin public interface MutableList { // 类型参数出现在 out 位置的方法被改写 public fun removeAt(index: Int): Any? // 类型参数出现在 in 位置的方法被保留 public fun add(index: Int, element: T): Unit ... } ``` `Any?`是所有类的父类，这也就很巧妙地让`MutableList`符合了第二条推论（`Any?`已经是最大的范围了，随便返回什么类型都是它的子类）最后，还有一种特殊的投影叫**star 投影**，它的效果是**in投影**和**out投影**之和。（详见下表） Kotlin 中一共有三种类型投影，总结如下（其中，Group、Dog、Animal都是类名，且 Dog 是 Animal 的子类型）： | 投影类型 | 投影实例 | 变型 | 继承关系 | 限制 | | ------ | ------ | ------ | ------| ------ | | out 投影 | Group< out Animal > | 协变 | Group< Dog > 是 Group< out Animal > 子类 | 类型参数不能作为方法参数 | in 投影 | Group< in Animal > | 逆变 | Group< in Animal > 是 Group< Dog > 子类 | 类型参数不能作为方法返回值 | star 投影 | Group< * > | -- | Group< 任何类型 > 都是 Group< * > 子类 | 类型参数不能做方法参数也不能做返回值 ## 推荐阅读 - [Kotlin 基础 | 委托及其应用](https://juejin.cn/post/6947830195034259469) - [Kotlin 基础 | 拒绝语法噪音](https://juejin.cn/post/6963054983067467790) - [Kotlin 进阶 | 不变型、协变、逆变](https://juejin.cn/post/6921508377998671886) - [Kotlin 实战 | 时隔一年，用 Kotlin 重构一个自定义控件](https://juejin.cn/post/6855129007798894599) - [Kotlin 实战 | 用语法糖干掉形状 xml 文件](https://juejin.cn/post/6872136025624444941) - [Kotlin 基础 | 望文生义的 Kotlin 集合操作](https://juejin.cn/post/6970853612352339981) - [Kotlin 源码 | 降低代码复杂度的法宝](https://juejin.cn/post/6976033228771721247) - [Kotlin 协程 | CoroutineContext 为什么要设计成 indexed set？（一）](https://juejin.cn/post/6978613779252641799) - [Kotlin 进阶 | 异步数据流 Flow 的使用场景](https://juejin.cn/post/6989032238079803429)