泛型
与 Java 类似，Kotlin 中的类也可以有类型参数：
class Box<T>(t: T) {
var value = t
}一般来说，要创建这样类的实例，我们需要提供类型参数：
val box: Box<Int> = Box<Int>(1)但是如果类型参数可以推断出来，例如从构造函数的参数或者从其他途径，允许省略类型参数：
val box = Box(1) // 1 具有类型 Int，所以编译器知道我们说的是 Box<Int>。型变
Java 类型系统中最棘手的部分之一是通配符类型（参见 Java Generics FAQ）。 而 Kotlin 中没有。 相反，它有两个其他的东西：声明处型变（declaration-site variance）与类型投影（type projections）。
首先，让我们思考为什么 Java 需要那些神秘的通配符。在 《Effective Java》第三版 解释了该问题——第 31 条：利用有限制通配符来提升 API 的灵活性。 首先，Java 中的泛型是不型变的，这意味着 List 并不是 List 的子类型。 为什么这样？ 如果 List 不是不型变的，它就没比 Java 的数组好到哪去，因为如下代码会通过编译然后导致运行时异常：
// Java
List<String> strs = new ArrayList<String>();
List<Object> objs = strs; // ！！！此处的编译器错误让我们避免了之后的运行时异常
objs.add(1); // 这里我们把一个整数放入一个字符串列表
String s = strs.get(0); // ！！！ ClassCastException：无法将整数转换为字符串因此，Java 禁止这样的事情以保证运行时的安全。但这样会有一些影响。例如，考虑 Collection 接口中的 addAll() 方法。该方法的签名应该是什么？直觉上，我们会这样：
// 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》第三版，第 28 条：列表优先于数组）
这就是为什么 addAll() 的实际签名是以下这样：
// Java
interface Collection<E> …… {
void addAll(Collection<? extends E> items);
}通配符类型参数 ? extends E 表示此方法接受 E 或者 E 的 一些子类型对象的集合，而不只是 E 自身。 这意味着我们可以安全地从其中（该集合中的元素是 E 的子类的实例）读取 E，但不能写入， 因为我们不知道什么对象符合那个未知的 E 的子类型。 反过来，该限制可以让Collection表示为Collection<? extends Object>的子类型。 简而言之，带 extends 限定（上界）的通配符类型使得类型是协变的（covariant）。
理解为什么这个技巧能够工作的关键相当简单：如果只能从集合中获取元素，那么使用 String 的集合， 并且从其中读取 Object 也没问题 。反过来，如果只能向集合中 放入 元素，就可以用 Object 集合并向其中放入 String：在 Java 中有 List<? super String> 是 List 的一个超类。
后者称为逆变性（contravariance），并且对于 List <? super String> 你只能调用接受 String 作为参数的方法 （例如，你可以调用 add(String) 或者 set(int, String)），当然如果调用函数返回 List 中的 T，你得到的并非一个 String 而是一个 Object。
Joshua Bloch 称那些你只能从中读取的对象为生产者，并称那些你只能写入的对象为消费者。他建议：“为了灵活性最大化，在表示生产者或消费者的输入参数上使用通配符类型”，并提出了以下助记符：
PECS 代表生产者-Extends、消费者-Super（Producer-Extends, Consumer-Super）。
注意：如果你使用一个生产者对象，如 List<? extends Foo>，在该对象上不允许调用 add() 或 set()。但这并不意味着该对象是不可变的：例如，没有什么阻止你调用 clear()从列表中删除所有元素，因为 clear() 根本无需任何参数。通配符（或其他类型的型变）保证的唯一的事情是类型安全。不可变性完全是另一回事。
声明处型变
假设有一个泛型接口 Source，该接口中不存在任何以 T 作为参数的方法，只是方法返回 T 类型值：
// Java
interface Source<T> {
T nextT();
}那么，在 Source 类型的变量中存储 Source 实例的引用是极为安全的——没有消费者-方法可以调用。但是 Java 并不知道这一点，并且仍然禁止这样操作：
// Java
void demo(Source<String> strs) {
Source<Object> objects = strs; // ！！！在 Java 中不允许
// ……
}为了修正这一点，我们必须声明对象的类型为 Source<? extends Object>，这是毫无意义的，因为我们可以像以前一样在该对象上调用所有相同的方法，所以更复杂的类型并没有带来价值。但编译器并不知道。
在 Kotlin 中，有一种方法向编译器解释这种情况。这称为声明处型变：我们可以标注 Source 的类型参数 T 来确保它仅从 Source 成员中返回（生产），并从不被消费。 为此，我们提供 out 修饰符：
interface Source<out T> {
fun nextT(): T
}
fun demo(strs: Source<String>) {
val objects: Source<Any> = strs // 这个没问题，因为 T 是一个 out-参数
// ……
}一般原则是：当一个类 C 的类型参数 T 被声明为 out 时，它就只能出现在 C 的成员的输出-位置，但回报是 C 可以安全地作为 C的超类。
简而言之，他们说类 C 是在参数 T 上是协变的，或者说 T 是一个协变的类型参数。 你可以认为 C 是 T 的生产者，而不是 T 的消费者。
out修饰符称为型变注解，并且由于它在类型参数声明处提供，所以我们称之为声明处型变。 这与 Java 的使用处型变相反，其类型用途通配符使得类型协变。
另外除了 out，Kotlin 又补充了一个型变注释：in。它使得一个类型参数逆变：只可以被消费而不可以被生产。逆变类型的一个很好的例子是 Comparable：
interface Comparable<in T> {
operator 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!