本文章已授权微信公众号郭霖（guolin_blog）转载。

本文章讲解的内容是泛型的型变，我写一个扩展Boolean的示例代码来应用我要讲的内容，示例代码如下：

BooleanExtensionDemo

先看下以下例子，代码如下：

List<String> strings = new ArrayList<String>();
// Java中禁止这样的操作
List<Object> objects = strings;

在Java中是禁止这样的操作的，我们看下Kotlin的写法，代码如下：

val strings: List<String> = arrayListOf()
val anys: List<Any> = strings

在Kotlin中是允许这样的操作的，这是为什么呢？下面会详细解释。

在List<String>中，List是基础类型，String是类型实参，现有两个List集合，分别是List<String>和List<Any>，它们都具有相同的基础类型，但是类型实参不相同，并且String和Any存在父子关系，型变就是指List<String>和List<Any>这两者存在什么关系。

形式参数和实际参数

函数中的形参和实参

代码如下：

fun add(firstNumber: Int, secondNumber: Int): Int =
    firstNumber + secondNumber

firstNumber和secondNumber就是形式参数，然后去调用这个函数，代码如下：

val first = 1
val second = 2
add(first, second)

first和second就是add函数的实际参数。

泛型中的形参和实参

代码如下：

class Fruit<T>(var item: T)

T就是类型形参，然后使用这个类，代码如下：

val fruit = Fruit<Int>(100)

Int就是Fruit的类型实参，因为Kotlin具有类型推导特性，不必明确指明类型，所以其实可以写成如下代码：

val fruit = Fruit(100)

在这种情况下，Int依然是Fruit的类型实参。

还有以下情况，请看代码：

// Collections.kt
public interface MutableList<E> : List<E>, MutableCollection<E> {
    // 省略部分代码
}

这里的E是List和MutableCollection的类型实参，同时是MutableList的类型形参。

结论

定义在里面就是形式参数，定义在外面就是实际参数。

子类、超类、子类型、超类型

子类会继承超类，例如class Apple: Fruit()，Apple就是Fruit的子类，Fruit就是Apple的超类，那什么是子类型和超类型呢？它们的规则比子类和超类更加宽松，如果需要A类型的地方，都可以用B类型来代替，那么B类型就是A类型的子类型，A类型就是B类型的超类型，例如String和String?，如果一个函数接收的是String?，我们传入的是String的话，编译器是不会报错的，但是如果一个函数接受的是String，我们传入的是String?的话，编译器就会提示我们可能会存在空指针的问题，所以String就是String?的子类型，String?就是String的超类型。

子类型化关系

如果需要A类型的地方，都可以用B类型来代替，那么B类型就是A类型的子类型，B类型到A类型之间的映射关系就是子类型化关系，举个例子：List<String>是List<Any>的子类型，所以List<String>到List<Any>之间存在子类型化关系，List<String>是List<String?>的子类型，所以List<String>到List<String?>之间存在子类型化关系，MutableList<String>和MutableList<Any>之间就没有关系，这个会在下面解释。

协变

协变（convariant）就是保留子类型化关系，保证泛型内部操作该类型时是只读的，在Java中，带extends限定（上界）的通配符类型使得类型是协变的。

因为List<out E>是协变，String是Any的子类型，String是String?的子类型，所以List<String>是List<Any>的子类型，List<String>是List<String?>的子类型。

out协变点

以下代码是标准的out协变点：

// T被声明为out
interface Producer<out T> {

    // T作为只读属性的类型
    val value: T

    // T作为函数返回值的类型
    fun produce(): T

    // T作为只读属性的类型List泛型的类型实参
    val list: List<T>

    // T作为函数返回值的类型List泛型的类型实参
    fun produceList(): List<T>

}

out协变点基本特征：出现的位置是只读属性的类型或者函数的返回值类型，它作为生产者的角色，请求向外部输出。

源码分析

在源码中，最为代表性就是List<out E>，代码如下：

// Collections.kt
// E被声明为out
public interface List<out E> : Collection<E> {

    override val size: Int
    override fun isEmpty(): Boolean

    // E作为函数形参类型，而且还加上了@UnsafeVariance注解，下面会解释
    override fun contains(element: @UnsafeVariance E): Boolean

    // E作为函数返回值的类型Iterator泛型的类型实参
    override fun iterator(): Iterator<E>

    // E作为函数形参的类型Collection泛型的类型实参，而且还加上了@UnsafeVariance注解，下面会解释
    override fun containsAll(elements: Collection<@UnsafeVariance E>): Boolean

    // E作为函数返回值的类型
    public operator fun get(index: Int): E

    // E作为函数形参类型，而且还加上了@UnsafeVariance注解，下面会解释
    public fun indexOf(element: @UnsafeVariance E): Int

    // E作为函数形参类型，而且还加上了@UnsafeVariance注解，下面会解释
    public fun lastIndexOf(element: @UnsafeVariance E): Int

    // E作为函数返回值的类型ListIterator泛型的类型实参
    public fun listIterator(): ListIterator<E>

    // E作为函数返回值的类型ListIterator泛型的类型实参
    public fun listIterator(index: Int): ListIterator<E>

    // E作为函数返回值的类型List泛型的类型实参
    public fun subList(fromIndex: Int, toIndex: Int): List<E>

}

逆变

逆变（contravariance）就是反转子类型化关系，保证泛型内部操作该类型时是只写的，在Java中，带super限定（下界）的通配符类型使得类型是逆变的。

因为Comparable<in T>是逆变，String是Any的子类型，String是String?的子类型，所以Comparable<Any>是Comparable<String>的子类型，Comparable<String?>是Comparable<String>的子类型。

in逆变点

以下代码是标准的in逆变点：

// T被声明为in
interface Consumer<in T> {

    // T作为函数形参类型
    fun consume(value: T)

    // T作为函数形参的类型List泛型的类型实参
    fun consumeList(list: List<T>)

}

in逆变点基本特征：出现的位置是函数形参类型，它作为消费者，请求外部输入。

源码分析

在源码中，最为代表性就是Comparable<in T>，代码如下：

// Comparable.kt
// T被声明为in
public interface Comparable<in T> {

    // T作为函数形参类型
    public operator fun compareTo(other: T): Int

}

不型变

不型变就是既不被声明为out，也不被声明为in的泛型。

因为MutableList<E>是不型变，虽然String是Any的子类型，String是String?的子类型，但是MutableList<String>和MutableList<Any>之间没有任何关系，MutableList<String>和MutableList<String?>之前没有任何关系。

不型变的基本特征：可以出现在任何位置。

源码分析

在源码中，最为代表性就是MutableList<E>，代码如下：

// Collections.kt
public interface MutableList<E> : List<E>, MutableCollection<E> {

    // E作为函数形参类型
    override fun add(element: E): Boolean

    // E作为函数形参类型
    override fun remove(element: E): Boolean

    // E作为函数形参的类型Collection泛型的类型实参
    override fun addAll(elements: Collection<E>): Boolean

    // E作为函数形参的类型Collection泛型的类型实参
    public fun addAll(index: Int, elements: Collection<E>): Boolean

    // E作为函数形参的类型Collection泛型的类型实参
    override fun removeAll(elements: Collection<E>): Boolean

    // E作为函数形参的类型Collection泛型的类型实参
    override fun retainAll(elements: Collection<E>): Boolean
    override fun clear(): Unit

    // E作为函数形参类型
    public operator fun set(index: Int, element: E): E

    // E作为函数形参类型
    public fun add(index: Int, element: E): Unit

    // E作为函数返回值的类型
    public fun removeAt(index: Int): E

    // E作为函数返回值的类型MutableListIterator泛型的类型实参
    override fun listIterator(): MutableListIterator<E>

    // E作为函数返回值的类型MutableListIterator泛型的类型实参
    override fun listIterator(index: Int): MutableListIterator<E>

    // E作为函数返回值的类型MutableList泛型的类型实参
    override fun subList(fromIndex: Int, toIndex: Int): MutableList<E>

}

@UnsafeVariance

在上面说的List<out E>源码中，我们发现虽然List<out E>是协变的，但是有时出现的位置是逆变的位置，这是为什么呢？其实是可以出现在任何位置上，但是要保证以下两点定义：协变保证泛型内部操作类型时是只读的，逆变保证泛型内部操作类型时是只写的，大体上要遵循上面说的那几个out协变点和in逆变点。

我们可以通过加上@UnsafeVariance注解告诉编译器这个地方是合法、安全，让其通过编译，如果不加的话，编译器会认为你这里是不合法，编译不通过。

例如上面说的List<out E>源码中，有一个contains函数，这个函数的作用是检查此元素是否包含在此集合中，它的实现方法没有出现写操作，所以这里就可以加上@UnsafeVariance注解，让其通过编译器。

使用处型变和声明处型变

Java是使用使用处型变，有如下接口：

public interface IGeneric<T> {
    // 省略部分代码
}

Java是禁止这样的操作的：

private void setData(IGeneric<String> item) {
    // Java禁止这样的操作
    IGeneric<Object> newItem = item;
}

我们应该写成如下这样：

private void setData(IGeneric<String> item) {
    IGeneric<? extends Object> newItem = item;
}

我们必须把newItem声明为IGeneric<? extends Object>，类型变得更复杂了，复杂的类型并没有给我们带来任何价值，这种就叫做使用处型变，我们看下Kotlin的写法吧，有如下接口：

// T被声明为out
interface IGeneric<out T> {
    // 省略部分代码
}

有如下方法：

private fun setData(item: IGeneric<String>) {

    // 泛型IGeneric的类型实参是Any
    val newItem: IGeneric<Any> = item

}

这种就做声明处型变，我们只需要在用out修饰符修饰T即可，语义简单了很多，当然Kotlin也可以使用使用处型变的，我们不再用out修饰符修饰T，代码如下：

interface IGeneric<T> {
    // 省略部分代码
}

然后我们在声明类型的时候加上out修饰符，代码如下：

private fun setData(item: IGeneric<String>) {

    // 泛型IGeneric的类型实参Any被声明为out
    val newItem: IGeneric<out Any> = item

}

星投影

定义

有时候，我们对类型参数一无所知，但是仍然希望以安全的方式使用它，我们可以使用星投影，这个泛型类型的每个具体实例化是这个投影的子类型。

语法

• 对于Function<out T : String>，T是泛型Function的一个具有上界String的协变类型参数，Function<>等价于Function<out String>，这意味着当T为未知时，我们可以安全地从Function<>读取String**的值。
• 对于Function<in T>，T是泛型Function的一个逆变类型参数，Function<>等价于Function<in Nothing>，这意味着当T为未知时，我们不能安全地写入Function<>**。
• 对于Function<T : String>，T是泛型Function的一个不型变类型参数，Function<>读取值时等价于Function<out String>，写入值时等价于Function<in Nothing>*。

如果一个泛型类型具有多个类型参数，那么它们每个类型参数都可以单独投影，例如：如果类型被声明为Function<in T, out U>，那么它的星投影就如下：

• Function<, String>表示Function<in Nothing, String>*
• Function<String, >表示Function<String, out Any?>*
• Function<, >表示Function<in Nothing, out Any?>

要注意的是星投影非常像Java的原始类型，但是是安全的。

这里解释一下Nothing，Nothing是所有类型的子类型，源码如下：

public class Nothing private constructor()

应用

我们可以扩展Boolean，让其更具有函数式编程的味道，让链式调用更加顺滑，代码如下：

package com.tanjiajun.booleanextensiondemo

/**
 * Created by TanJiaJun on 2020-01-28.
 */
sealed class BooleanExt<out T>

class TransferData<T>(val data: T) : BooleanExt<T>()
object Otherwise : BooleanExt<Nothing>()

inline fun <T> Boolean.yes(block: () -> T): BooleanExt<T> =
    when {
        this -> TransferData(block.invoke())
        else -> Otherwise
    }

inline fun <T> BooleanExt<T>.otherwise(block: () -> T): T =
    when (this) {
        is Otherwise -> block()
        is TransferData -> data
    }

调用地方，代码如下：

package com.tanjiajun.booleanextensiondemo

import android.os.Bundle
import android.util.Log
import androidx.appcompat.app.AppCompatActivity

/**
 * Created by TanJiaJun on 2020-01-28.
 */
class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // 第一个例子
        val name = "谭嘉俊"
        (name == "谭嘉俊")
            .yes { Log.i("TanJiaJun", name) }
            .otherwise { Log.i("TanJiaJun", "苹果") }

        // 第二个例子
        val strings = mutableListOf(2, 4, 6, 8, 10)
        (strings
            .filter { it % 2 == 0 }
            .count() == strings.size)
            .yes { Log.i("TanJiaJun", "是偶数集合") }
            .otherwise { Log.i("TanJiaJun", "不是偶数集合") }
    }

}

我们可以看到密封类BooleanExt，它是个泛型，T是一个协变类型参数，为什么要用到协变呢？我们可以观察到T都出现在out协变点，所以T可以被声明为out。

我们还看到对象Otherwise继承密封类BooleanExt，我使用了Nothing，为什么要使用Nothing呢？因为在Boolean的扩展函数yes中返回的是BooleanExt<T>，如果要返回Otherwise，我们就只能使用Nothing，因为Nothing是所有类型的子类型，上面也提及过，所以这样就符合协变的定义了。

题外话

PECS原则

PECS原则是指Producer-Extends, Consumer-Super，它是Effective Java提出来的，如果泛型的类型实参是生产者，那么就应该用extends；如果泛型的类型实参是消费者，那么就应该用super。

密封类

在我的示例代码中，我用到了sealed这个修饰符，它可以声明一个密封类，我这里大概说下密封类：

• 密封类用来表示受限的类继承结构，意思就是当一个值为有限几种的类型，而不能有任何其他类型，其实他们在某种意义上，有点像枚举类的扩展，不过枚举类型的值集合是受限的，每个枚举常量只存在一个实例，而密封类的一个子类可以有包含状态的多个实例。

• 密封类可以有子类，但是所有子类必须在与密封类自身相同的文件中声明。

• 密封类自身是抽象的，它不能直接实例化，但是可以有抽象成员。

• 密封类不允许有非private构造函数，它的构造函数就是private的。

• 扩展密封类子类的类可以放在任何位置，而不需要放在同一个文件中。

• 使用密封类还有个好处在于使用when表达式的时候，当我们用when作为表达式的时候，也就像上面示例代码中的otherwise，我是使用了它的结果，而不是作为语句，如果能够验证语句覆盖了所有情况的时候，我们就不需要再为语句添加一个else子句了。

我的GitHub：TanJiaJunBeyond

Android通用框架：Android通用框架

我的掘金：谭嘉俊

我的简书：谭嘉俊

我的CSDN：谭嘉俊