# 泛型
与 Java 中一样，Kotlin 中的类可以有类型参数：
``` kotlin
class Box<T>(t: T) {
var value = t
}
```
通常，要创建一个类的实例，我们需要提供类型实参：
``` kotlin
val box: Box<Int> = Box<Int>(1)
```
但是如果参数可以推断，例如从构造器实参或通过其它的手段，都允许省略类型实参：
``` kotlin
val box = Box(1) // 1 有类型 Int，因此编译器会以整数看待，我们称之为 Box<Int>
```
## 变化
Java 类型系统最复杂部分的其中之一的通配符类型（查看[Java 泛型问答](http://www.angelikalanger.com/GenericsFAQ/JavaGenericsFAQ.html)） Kotlin 并没有。作为替代，它有两种其它的东西：声明场所差异和类型预测。
首先，让我们想一想关于为什么 Java 需要那些诡异的通配符。问题就是在 [Effective Java](http://www.oracle.com/technetwork/java/effectivejava-136174.html)，Item 28：*Use bounded wildcards to increase API flexibility*。首先，Java 中的泛型是不变的，意思就是 `List<String>` 不是 `List<Object>` 的子类型。为什么是这样？如果 List 不是不变的，它应该几乎等于 Java 的数组，因此下面的代码会通过编译然后在运行时引发一个错误：
``` java
// Java
List<String> strs = new ArrayList<String>();
List<Object> objs = strs; // !!! 这里即将引发一个问题。Java 禁止这样
objs.add(1); // 这里我们放置一个 Integer 到一个 String list 中
String s = strs.get(0); // !!! ClassCastException: Cannot cast Integer to String
```
因此，Java 为了保证运行时的安全禁止这样的东西。但这有一些隐患。例如，考虑 `Collection` 接口的 `addAll()` 方法，这个方法的签名是什么？凭直觉我们应该这样放置它：
``` java
// Java
interface Collection<E> ... {
void addAll(Collection<E> items);
}
```
但另一方面，我们应该不能做到下面这样简单的事（完全是安全的）：
``` java
// Java
void copyAll(Collection<Object> to, Collection<String> from) {
to.addAll(from); // !!! 这种幼稚的 addAll 声明不能被编译
// Collection<String> 不是 Collection<Object> 的子类型
}
```
（Java 中，我们都学过这种困难的课程，查看 [Effective Java](http://www.oracle.com/technetwork/java/effectivejava-136174.html), Item 25: *Prefer lists to arrays*）
那就是为什么实际的 `addAll()` 签名是下面这样：
``` java
// Java
interface Collection<E> ... {
void addAll(Collection<? extends E> items);
}
```
**通配符类型实参** `? extends T` 指示这个方法接受*类型为 `T` 的一些子类型，而非 `T` 本身*的对象的集合。这个意思是我们可以从项目中安全地**读** `T`（这个集合的元素都是一个 T 子类的实例），但**不能写**进它，由于我们不知道什么对象才是 `T` 的未知子类型。在这种限制的返回中，我们有了所期望的行为： `Collection<String>` *是* `Collection<? extends T>` 的子类型。在“clever words”中，通配符与扩展边界（上层边界）一起构成了类型**协变**。
理解的关键在于为什么这个工作策略如此简单：如果你可以仅仅从一个集合接受项目，然后很好地使用一个集合的 `String` 并读取 `Object`。反过来，如果你可以仅仅_放置_项目到集合里，它可以很好地从拿取一个集合的 `Object` 并放置 `String` 到它里面：Java 中我们有 `List<Object>` 的超类 `List<? super String>`。
后者称为**抗变性**，而且你可以在 `List<? super String>` 上只像实参一样调用方法来拿取 String （例如，你可以调用 `add(String)` 或 `set(int, String)`），在此期间如果你调用什么在 `List<T>` 中返回了 `T`，那么你得不到一个 `String`，而是一个 `Object`。
Joshua Bloch 称那些对象你只能从**生产者** **读取**，并且只能 **写入** 到 **消费者**。他推荐：“*为了弹性最大化，要在输入的参数上使用通配符来表示生产者和消费者*”，并提出下列助记词：
*PECS 代表 生产者 Extends，消费者 Super*
*注意*：如果你使用一个生产者对象，就是说 `List<? extends Foo>`，你不允许在这个对象上调用 `add()` 或者 `set()`，但这个意思不是说这个对象是**不变的**：例如，没有什么阻止你调用 `clear()` 从 list 移除所有的项目，由于 `clear()` 根本不需要任何参数。仅仅只通过通配符（或其它可变类型）确保**类型安全**。不变性完全是另一回事。
### 声明场所差异
假设我们有一个泛型接口 `Source<T>`，没有任何方法而只有一个 `T` 作为参数，仅有的方法是返回 `T`：
``` java
// Java
interface Source<T> {
T nextT();
}
```
然后，它应该是完美地在一个类型为 `Source<Object>` 中安全地存储一个 `Source<String>` 实例引用 —— 没有消费者方法可以被调用。但 Java 并不知道这一点，而仍然会禁止它：
``` java
// Java
void demo(Source<String> strs) {
Source<Object> objects = strs; // !!! 在 Java 中是不允许的
// ...
}
```
要修复这一点，我们不得不以无意义的方式声明类型为 `Source<? extends Object>` 的对象，因为我们可以像前面那样调用这种变量上所有相同的方法，因此没有值通过更复杂的类型被加入。但编译器并不知道。
在 Kotlin 中，有一种途径向编译器说明这类东西。称之为**声明场所差异**：我们可以注解源码的**类型参数** `T` 来确保它是只从 `Source<T>` 的成员**返回**（生产），而从不消费。对这个我们提供了 `out` 标识符：
``` kotlin
abstract class Source<out T> {
abstract fun nextT(): T
}
fun demo(strs: Source<String>) {
val objects: Source<Any> = strs // 由于 T 是一个 out 参数，这样就 OK 了
// ...
}
```
通用的规则是：当一个 `C` 类的类型参数 `T` 被声明为 `out`，它会仅在 `C` 类成员的 `out` 位置存在，但返回的 `C<Base>` 可以安全地成为 `C<Derived>` 的超类。
在 clever words 中他们会说类 `C` 在参数 `T` 中是协变的，或者 `T` 是一个协变的类型参数。你可以想到 `C` 如同是 `T` 的**生产者**，并非 `T` 的**消费者**。
`out` 标识符被称作**差异注解**，并且由于它是在声明类型参数的场所提供的，我们就会说**声明场所差异**。这是相对于 Java 的在通配符在类型协变用法中的**使用场所差异**而言的。
除 `out` 之外，Kotlin 提供了一个配套的真协变注解：`in`。它使得一个类型参数**逆变**：它仅能作为消费者并从不生产。逆变的一个好例子是类 `Comparable`：
``` kotlin
abstract class Comparable<in T> {
abstract fun compareTo(other: T): Int
}
fun demo(x: Comparable<Number>) {
x.compareTo(1.0) // 1.0 有 Number 的子类 Double
// 因此，我们可以把 x 赋值给一个类型为 Comparable<Double> 的变量
val y: Comparable<Double> = x // OK!
}
```
我们相信单词 `in` 和 `out` 是自解释的（就像它们有时也能成功地在 C# 中使用一样），因此上面所提到的情况中并非真正需要，而是为了更高级的目的：
**[The Existential](http://en.wikipedia.org/wiki/Existentialism) 变成：消费者 `in`，生产者 `out`！**:-)
## 类型投影
### 使用场所可变：类型投影
这非常适合于声明一个类型参数 T 为 `out` 并且不会在子类使用场所中遇到麻烦。当类考虑**能**被真正地限制为只返回 `T` 时是这样，但如果不能呢？这个数组是个好例子：
``` kotlin
class Array<T>(val size: Int) {
fun get(index: Int): T { /* ... */ }
fun set(index: Int, value: T) { /* ... */ }
}
```
这个类在 `T` 中既不能合作也不可逆变，并强制成不可变的。考虑下面的函数：
``` kotlin
fun copy(from: Array<Any>, to: Array<Any>) {
assert(from.size == to.size)
for (i in from.indices)
to[i] = from[i]
}
```
这个函数假定从一个数组复制项目到另一个。让我们尝试在实践中应用它：
``` kotlin
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>` 都不是彼此的子类型。为什么呢？再说一遍，因为复制可能会做坏事，意即它会尝试写入，就是说一个字符串给 `from`，而如果我们在那里又传递一个 `Int` 数组，那么 `ClassCastException` 会在后面某时被抛出。
此时，我们要做的事仅仅是确保 `copy()` 不会做什么坏事。我们阻止它向 `from` 写入，于是我们可以：
``` kotlin
fun copy(from: Array<out Any>, to: Array<Any>) {
// ...
}
```
所发生的这些事称之为**类型投影**：我们说过 `from` 不是简单的一个数组，但它是一个受限制（**投影**）的数组：我们只能调用那些返回类型参数 `T` 的方法，在这种情况下它的意思是我们只能调用 `get()`。这是我们近似于**使用场所差异**，并符合 Java 的 `Array<? extends Object>`，但更简单一点的方式。
你还可以设计一个与 `in` 一起的类型：
``` kotlin
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 的原始类型非常相似，但很安全。
# 泛型函数
并非只有类可以有类型参数。函数也可以。类型参数放置在函数名前面：
``` kotlin
fun <T> singletonList(item: T): List<T> {
// ...
}
fun <T> T.basicToString() : String { // extension function
// ...
}
```
如查类型参数在调用场所被明确地传递，它们要在函数名**后面**指定：
``` kotlin
val l = singletonList<Int>(1)
```
# 泛型约束
可以替代给出的类型参数的可能的类型可以通过**泛型约束**加以限制。
## 上界
大多数限制通用约束的类型是**上界**，与 Java 的 *extends* 关键字相符：
``` kotlin
fun <T : Comparable<T>> sort(list: List<T>) {
// ...
}
```
在冒号后面指定的类型就是**上界**：只有 `Comparable<T>` 的子类型可以代替 `T`。例如
``` kotlin
sort(listOf(1, 2, 3)) // OK。Int 是 Comparable<Int> 的子类型
sort(listOf(HashMap<Int, String>())) // 错误：HashMap<Int, String> 不是 Comparable<HashMap<Int, String>> 的子类型
```
默认的上界（如果未指定）是 `Any?`。尖括号里面只能指定一个上界。如果相同的类型参数需要多于一个上界，我们需要一个独立的 **where** 子句：
``` kotlin
fun <T> cloneWhenGreater(list: List<T>, threshold: T): List<T>
where T : Comparable,
T : Cloneable {
return list.filter { it > threshold }.map { it.clone() }
}
```
