Kotlin-简约之美-进阶篇（九）：泛型

@[toc]
Kotlin 的泛型与 Java 一样，都是一种语法糖，只在源代码里出现，编译时会进行简单的字符串替换。泛型（Generics）其实就是把类型参数化，真正的名字叫做 类型参数，它给强类型编程语言加入了更强的灵活性。在 Java 中，只要是有类型的 API 元素，都可以泛型化，也就是泛型类、泛型接口、泛型方法和泛型属性，泛型类和泛型接口可以统称为泛型类型。其中最重要的是泛型类型和泛型方法，Kotlin 泛型系统继承了 Java 泛型系统，同时添加了一些强化的地方。

泛型类

首先我们看一下 Kotlin 的泛型类型。Kotlin 的泛型类型的定义和使用方法大体上与 Java 相同，比如我们可以这样写：

class Box<T>(val value: T)

// 以下都是合法的语句
val box1: Box<Int> = Box<Int>(1)
val box2: Box<Int> = Box(1)
val box3 = Box(1)

定义泛型类型，是在类型名之后、主构造函数之前用尖括号括起的大写字母类型参数指定；

定义泛型类型变量，可以完整地写明类型参数，如果编译器可以自动推定类型参数，也可以省略类型参数。

泛型方法

Kotlin 泛型函数的声明与 Java 相同，类型参数要放在函数名的前面：

fun <T> boxIn(value: T) = Box(value)

// 以下都是合法语句
val box4 = boxIn<Int>(1)
val box5 = boxIn(1)

在调用泛型函数时，如果可以推断出类型参数，可以省略泛型参数。

在泛型方法的类型参数里可以用冒号 : 指定上界：

fun <T : Comparable<T>> sort(list: List<T>) {/*...*/}
对于多个上界约束条件，可以用 where 子句：

fun <T> cloneWhenGreater(list: List<T>, threshold: T): List<T>
    where T : Comparable, Cloneable {
      return list.filter(it > threshold).map(it.clone())
}

生产者与消费者

在 Java 泛型里，有通配符这种东西，我们要用 ? extends T 指定类型参数的上限，用 ? super T 指定类型参数的下限。Kotlin 抛弃了这个系统，引用了生产者和消费者的概念。

什么是生产者？生产者是那些只能 读取 数据的对象；

什么是消费者？消费者是那些只能 写入 数据的对象；

要理解这个概念，我们可以看一个例子：

public interface Collection<E> extends Iterable<E> {
  boolean add(E e);
  boolean addAll(Collection<? extends E> c);
}

这是 Collection 接口的add() 和 addAll() 方法，传入它们的类型参数一个是 E ，一个是 ? extends E，为什么呢？这两个方法之间不就是批量操作的区别吗？为什么一个只接受 E 类型的参数，另一个却接受 ? extend E 的类型？

这是因为，Java 泛型是不型变的，也就是说，虽然 String 类型是 Object 类型的子类型，但 Collection<String> 并不是 Collection<Object> 的子类型。

对于一个 Collection<Object> 来说，因为 String 是 Object 的子类型，一个 String 对象就是 Object 类型，所以可以直接把它添加入 Collection<Object> 里，add() 方法的类型参数因为可以设为 E；而想把 Collection<String> 添加入 Collection<Object> 时，因为 Java 泛型不型变的原因，就会出现编译错误，必须用 ? extends E 将 Collection<String> 囊括到 Collection<Object> 里。

从另一个角度看，对于一个 Collection<A>，我们从其中读取出一个对象，这个对象可以是 A 的子类型，也可以是 A 类型，这种特性叫 协变（Convariant）；而要向 Collection<A> 写入一个对象时，我们既可以写入一个 A 类型对象，也可以写入 A 的父类型，这种特性叫 逆协变（contravariance），协变和逆协变都是类型安全的。

从这个角度来说，我们可以把那些只能保证读取数据时类型安全的对象叫做生产者，用 out T 标记；把那些只能保证写入数据安全时类型安全的对象叫做消费者，用 in T 标记。

如果你觉得太晦涩难懂，就这么记吧：out T 等价于 ? extends T，in T 等价于 ? super T，此外还有 * 等价于 ?。

声明处型变

Kotlin 对 Java 泛型最大的改动就是添加了声明处型变。看下面的例子：

interface Source<T> {
  T nextT();
}

void demo(Source<String> str) {
  // Java 中这种写法是不允许的
  Source<Object> obj = str;
  /*...*/
}

因为 Java 泛型是不型变的，Source<String> 不是 Source<Object> 的子类型，所以不能把 Source<String> 类型变量赋给 Source<Object> 类型变量。

现在用 Kotlin 改写上面的接口声明：

interface Source<out T> {
  T nextT();
}

我们在接口的声明处用 out T 做了生产者声明，因为这个接口只有一个读取数据的 nextT() 方法，可以视为生产者。把这个接口的类型参数声明为生产者后，就可以实现安全的类型协变了：

fun demo(Source<String> str) {
  val obj: Source<Any> = str // 合法的类型协变
  /*...*/
}

Kotlin 中有大量的声明处协变，比如 Iterable 接口的声明：

public interface Iterable<out T> {
    public operator fun iterator(): Iterator<T>
}

因为 Collection 接口和 Map 接口都继承了 Iterable 接口，而 Iterable 接口被声明为生产者接口，所以所有的 Collection 和 Map 对象都可以实现安全的类型协变：

val c: List<Number> = listOf(1, 2, 3)

这里的 listOf() 函数返回 List<Int> 类型，因为 List 接口实现了安全的类型协变，所以可以安全地把 List<Int> 类型赋给 List<Number> 类型变量。