class Box<T>(t: T) {
    var value = t
}

一般来说，要创建这样类的实例，我们需要提供类型参数：

val box: Box<Int> = Box<Int>(1)

val box = Box(1) // 1 具有类型 Int，所以编译器知道我们说的是 Box<Int>。

// Java
List<String> strs = new ArrayList<String>();
List<Object> objs = strs; // ！！！即将来临的问题的原因就在这里。Java 禁止这样！
objs.add(1); // 这里我们把一个整数放入一个字符串列表
String s = strs.get(0); // ！！！ ClassCastException：无法将整数转换为字符串

// Java
interface Collection<E> …… {
  void addAll(Collection<E> items);
}

// Java
void copyAll(Collection<Object> to, Collection<String> from) {
  to.addAll(from); // ！！！对于这种简单声明的 addAll 将不能编译：
                   //       Collection<String> 不是 Collection<Object> 的子类型
}

(在 Java 中，我们艰难地学到了这个教训，参见Effective Java，第25条：列表优先于数组)

这就是为什么 addAll() 的实际签名是以下这样

// Java
interface Collection<E> …… {
  void addAll(Collection<? extends E> items);
}

通配符类型参数 ? extends E 表示此方法接受 E 的 一些子类型对象的集合，而不是 E 本身。
这意味着我们可以安全地从其中(该集合中的元素是 E 的子类的实例)读取 E，但不能写入，
因为我们不知道什么对象符合那个未知的 E 的子类型。
反过来，该限制可以让Collection<String>表示为Collection<? extends Object>的子类型。
简而言之，带 extends 限定(上界)的通配符类型使得类型是协变的(covariant)。

理解为什么这个技巧能够工作的关键相当简单：如果只能从集合中获取项目，那么使用 String 的集合，
并且从其中读取 Object 也没问题 。反过来，如果只能向集合中 放入 项目，就可以用
Object 集合并向其中放入 String：在 Java 中有 List<? super String> 是 List<Object> 的一个超类。

后者称为逆变性(contravariance)，并且对于 List <? super String> 你只能调用接受 String 作为参数的方法
(例如，你可以调用 add(String) 或者 set(int, String))，当然
如果调用函数返回 List<T> 中的 T，你得到的并非一个 String 而是一个 Object。

Joshua Bloch 称那些你只能从中读取的对象为生产者，并称那些你只能写入的对象为消费者。他建议：“为了灵活性最大化，在表示生产者或消费者的输入参数上使用通配符类型”，并提出了以下助记符：

PECS 代表生产者-Extens，消费者-Super(Producer-Extends, Consumer-Super)。

注意：如果你使用一个生产者对象，如 List<? extends Foo>，在该对象上不允许调用 add() 或 set()。但这并不意味着
该对象是不可变的：例如，没有什么阻止你调用 clear()从列表中删除所有项目，因为 clear()
根本无需任何参数。通配符(或其他类型的型变)保证的唯一的事情是类型安全。不可变性完全是另一回事。

声明处型变

假设有一个泛型接口 Source<T>，该接口中不存在任何以 T 作为参数的方法，只是方法返回 T 类型值：

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

// Java
void demo(Source<String> strs) {
  Source<Object> objects = strs; // ！！！在 Java 中不允许
  // ……
}

为了修正这一点，我们必须声明对象的类型为 Source<? extends Object>，这是毫无意义的，因为我们可以像以前一样在该对象上调用所有相同的方法，所以更复杂的类型并没有带来价值。但编译器并不知道。

在 Kotlin 中，有一种方法向编译器解释这种情况。这称为声明处型变：我们可以标注 Source 的类型参数 T 来确保它仅从 Source<T> 成员中返回(生产)，并从不被消费。
为此，我们提供 out 修饰符：

abstract class Source<out T> {
    abstract fun nextT(): T
}

fun demo(strs: Source<String>) {
    val objects: Source<Any> = strs // 这个没问题，因为 T 是一个 out-参数
    // ……
}

一般原则是：当一个类 C 的类型参数 T 被声明为 out 时，它就只能出现在 C 的成员的输出-位置，但回报是 C<Base> 可以安全地作为
C<Derived>的超类。

简而言之，他们说类 C 是在参数 T 上是协变的，或者说 T 是一个协变的类型参数。
你可以认为 C 是 T 的生产者，而不是 T 的消费者。

out修饰符称为型变注解，并且由于它在类型参数声明处提供，所以我们讲声明处型变。
这与 Java 的使用处型变相反，其类型用途通配符使得类型协变。

另外除了 out，Kotlin 又补充了一个型变注释：in。它使得一个类型参数逆变：只可以被消费而不可以
被生产。逆变类的一个很好的例子是 Comparable：

abstract class Comparable<in T> {
    abstract fun compareTo(other: T): Int
}

fun demo(x: Comparable<Number>) {
    x.compareTo(1.0) // 1.0 拥有类型 Double，它是 Number 的子类型
    // 因此，我们可以将 x 赋给类型为 Comparable <Double> 的变量
    val y: Comparable<Double> = x // OK！
}

我们相信 in 和 out 两词是自解释的(因为它们已经在 C# 中成功使用很长时间了)，
因此上面提到的助记符不是真正需要的，并且可以将其改写为更高的目标：

存在性(The Existential) 转换：消费者 in, 生产者 out! :-)

类型投影

使用处型变：类型投影

将类型参数 T 声明为 out 非常方便，并且能避免使用处子类型化的麻烦，但是有些类实际上不能限制为只返回 T！
一个很好的例子是 Array：

class Array<T>(val size: Int) {
    fun get(index: Int): T { ///* …… */ }
    fun set(index: Int, value: T) { ///* …… */ }
}

fun copy(from: Array<Any>, to: Array<Any>) {
    assert(from.size == to.size)
    for (i in from.indices)
        to[i] = from[i]
}

val ints: Array<Int> = arrayOf(1, 2, 3)
val any = Array<Any>(3)
copy(ints, any) // 错误：期望 (Array<Any>, Array<Any>)

这里我们遇到同样熟悉的问题：Array <T> 在 T 上是不型变的，因此 Array <Int> 和 Array <Any> 都不是
另一个的子类型。为什么？ 再次重复，因为 copy 可能做坏事，也就是说，例如它可能尝试写一个 String 到 from，
并且如果我们实际上传递一个 Int 的数组，一段时间后将会抛出一个 ClassCastException 异常。

那么，我们唯一要确保的是 copy() 不会做任何坏事。我们想阻止它写到 from，我们可以：

fun copy(from: Array<out Any>, to: Array<Any>) {
 // ……
}

这里发生的事情称为类型投影：我们说from不仅仅是一个数组，而是一个受限制的(投影的)数组：我们只可以调用返回类型为类型参数
T 的方法，如上，这意味着我们只能调用 get()。这就是我们的使用处型变的用法，并且是对应于 Java 的 Array<? extends Object>、
但使用更简单些的方式。

你也可以使用 in 投影一个类型：

fun fill(dest: Array<in String>, value: String) {
    // ……
}

Array<in String> 对应于 Java 的 Array<? super String>，也就是说，你可以传递一个 CharSequence 数组或一个 Object 数组给 fill() 函数。

星投影

有时你想说，你对类型参数一无所知，但仍然希望以安全的方式使用它。
这里的安全方式是定义泛型类型的这种投影，该泛型类型的每个具体实例化将是该投影的子类型。

Kotlin 为此提供了所谓的星投影语法：

• 对于 Foo <out T>，其中 T 是一个具有上界 TUpper 的协变类型参数，Foo <*> 等价于 Foo <out TUpper>。 这意味着当 T 未知时，你可以安全地从 Foo <*> 读取 TUpper 的值。
• 对于 Foo <in T>，其中 T 是一个逆变类型参数，Foo <*> 等价于 Foo <in Nothing>。 这意味着当 T 未知时，没有什么可以以安全的方式写入 Foo <*>。
• 对于 Foo <T>，其中 T 是一个具有上界 TUpper 的不型变类型参数，Foo<*> 对于读取值时等价于 Foo<out TUpper> 而对于写值时等价于 Foo<in Nothing>。

如果泛型类型具有多个类型参数，则每个类型参数都可以单独投影。
例如，如果类型被声明为 interface Function <in T, out U>，我们可以想象以下星投影：

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

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

泛型函数

fun <T> singletonList(item: T): List<T> {
    // ……
}

fun <T> T.basicToString() : String {  // 扩展函数
    // ……
}

val l = singletonList<Int>(1)

能够替换给定类型参数的所有可能类型的集合可以由泛型约束限制。

上界

最常见的约束类型是与 Java 的 extends 关键字对应的 上界：

fun <T : Comparable<T>> sort(list: List<T>) {
    // ……
}

sort(listOf(1, 2, 3)) // OK。Int 是 Comparable<Int> 的子类型
sort(listOf(HashMap<Int, String>())) // 错误：HashMap<Int, String> 不是 Comparable<HashMap<Int, String>> 的子类型

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