1 泛型

泛型即 “参数化类型”，将类型参数化，可以用在类，接口，函数上。与 Java 一样，Kotlin 也提供泛型，为类型安全提供保证，消除类型强转的烦恼。

1.1 泛型优点

1. 类型安全：通用允许仅保留单一类型的对象。泛型不允许存储其他对象。
2. 不需要类型转换：不需要对对象进行类型转换。
3. 编译时检查：在编译时检查泛型代码，以便在运行时避免任何问题。

1.2 泛型声明

1.2.1 泛型类

interface List<T> {fun get(index: Int): T
}

泛型参数可在类中当普通类型使用。

1.2.2 泛型函数

fun <T> lastElement(list: List<T>): T { ... }

在 fun 关键字后声明 泛型形参，可在参数和返回值处声明使用。高阶函数的例子：

fun <T> List<T>.filter(pridicate: (T) -> Boolean): List<T> { ... }

1.2.3 泛型属性

val <T> List<T>.last: Tget() {return last()}

不管是泛型类、泛型函数还是泛型属性，在使用之前必然已经确定了类型。如泛型类在实例化时需要指定泛型类型，泛型函数在调用时必然已推导出泛型类型，并替换为确定的类型实参，泛型属性同理。

1.3 泛型约束

泛型（类型参数）是有边界的，可以给泛型设置边界：

interface NumberList<T: Number> {fun get(index: Int): T
}

不指定边界，则默认上边界为 Any?。如果希望非空，需要显示指定为 <T: Any> 。

2 泛型擦除

和 Java 一样，Kotlin 中的类型参数也会在运行时被擦除，就是说泛型实例的类型实参在运行时是不保留的。不过 Kotlin 可以通过类型参数实化的方式保留类型信息，需要使用内联函数。

由于泛型擦除，下面的普通方法是无法编译的：

fun <T> isA(obj: Any): Boolean {return obj is T
}

通过内联，下面代码可以通过编译：

inline fun <reified T> isA(obj: Any): Boolean {return obj is T
}

注意带 reified 类型参数的内联函数不能在 Java 代码中使用，普通内联函数在 Java 中可以像常规函数一样调用，而 reified 的类型参数需要额外处理将类型实参替换到字节码，是永远需要内联的。
实化类型参数也是有限制的，具体可以做：

1. 类型转换和检查： 如 is 、as
2. 使用反射： T::class
3. 获取 java class： T::class.java
4. 作为调用其他函数类型的实参。

3 变型

变型描述的是具有相同基础类型和不同类型参数的泛型类型之间的关系。这种关系可以是 协变的 或 逆变的。

先说说不变型，一个泛型类如 MutableList ，对任意两种类型实参 A、B，MutableList<A> 既不是 MutableList<B> 的子类型也不是它的超类型，则称 该类在该类型参数上是不变型的。Java 中的泛型类对所有类型参数都是不变型的。比如 Java 中你不能把一个 List<Ingeter> 实例传给形参是 List<Number> 的函数，即使 Integer 是 Number 的子类。

前面说的子父类型关系类似于类的子父类关系，比如 A 是 B 的子类，那么 A 是 B 的子类型，任一非空类型是其可空类型的子类型，比如 Person 是 Person? 的子类型，下面会说到 Kotlin 中借助协变使得 List<Int> 能够成为 List<Number> 的子类型，注意区分 子类 和 子类型。

Kotlin 中，比如上面自定义的 List 接口，也是不变型的，List<Int> 并不是 List<Number> 的子类型，因此你不能把一个 List<Int> 实例传给形参是 List<Number> 的函数。

注意 Kotlin 标准库中的 List 接口是可以的，因为是协变的，别和这里自定义的 List 搞混了

3.1 Out (协变)

对于 out 泛型，我们能够将使用子类泛型的对象赋值给使用父类泛型的对象。如果将上面的 List 接口定义改为：

interface List<out T> {fun get(index: Int): T
}

则称该 List 接口是协变的，如果基础类型间有子类型关系，则泛型类也具有相同的子类型关系。如 Int 是 Number 的子类型，则 上面定义的 List<Int> 也是List<Number> 的子类型。这样就可以将 一个 List<Int> 实例传给形参是 List<Number> 的函数了，简单来说协变——父类引用指向子类

当然，out 也不可以滥用 ，因为不安全，比如将一个 List<Int> 实例传入形参是 List<Any> 的函数，该函数像实例中添加 Any 类型的数据显然是错误的：

fun addMore(list: List<Any>) {list.add("abc")
}
addMore(listOf(1, 2, 3))

为了防止这种风险，如果类在该类型参数上是协变的，那么该类型参数只能出现在返回值位置，我们称之为 out 位置，即该泛型参数只读，编译器也会做这种检查。Kotlin 中的 List 接口就是协变的。集合可读、不可写，集合泛型协变。

3.2 In (逆变)

和协变相反，对于 in 泛型，我们可以将使用父类泛型的对象赋值给使用子类泛型的对象。如果一个泛型类 MyClass 是逆变的，则对于 有子类型关系的 A 和 B（A是B的子类型），则 MyClass<A> 是 MyClass<B> 的超类型。逆变——子类引用指向父类

例如 Comparable 接口：

public interface Comparable<in T> {public operator fun compareTo(other: T): Int
}

那么，Comparable<Any> 是 Comparable<Int> 的子类型。可以尝试理解成“能对 Any 类型进行比较”的比较器也能比较 Int 类型“。

类似的，这里的泛型参数只能出现在函数参数位置，我们称之为 in 位置。集合可读 Any 、可写，集合泛型逆变。

3.3 声明点变型

即声明泛型的地方产生变型。前面说的变型是针对类的所有实例的。而声明点变型则可以只针对某一实例变型。如：

val list: MutableList<out Int> = MutableList()
list.add(1,2) //报错

上面代码会将 list 变为只读的。

在 Java 中，没有类的变型声明，只通过声明点产生型变，如：

public interface Stream<T> {<R> Stream<R> map(Function<? super T, ? extends R> mapper);
}

与 Kotlin 不同的是，Java 通过 ? super T 产生逆变，? extends R 产生协变。

3.4 星号投影

List<*> 对应与 Java 中的 List<?>， 表示不确定的任意类型类型实参。可能是 Int，可能是Any，是确定的某种类型，但对使用者是未知的，因而不能生产该值，只能访问，当作 Any? 访问。注意和 List<Any?> 作区分。

4 小结

1. Kotlin 的泛型概念和声明和 Java 相当接近。
2. Kotlin 的类型实参和 Java 一样会在运行期擦除。
3. Kotlin 可以通过类型参数实化保留运行时类型实参，需要借助内联函数。
4. 变型指的是具有相同基础类型和不同类型参数的泛型类型间的子类型关系。他指出了如果一个泛型类型的类型参数是另一个泛型类型类型参数的子类型，那么这个泛型类就是另一个泛型类的子类型或超类型。
5. 如果某个类在一个类型参数上声明成协变的，那么该类型参数只能出现在 out 位置上。逆变相反。Java 的泛型类都是不变型的。
6. 声明点泛型只在声明处产生变型，Java 的变型都是该方式。Kotlin 既可以使用声明点变型，也可以在整个泛型类上声明变型。
7. 如果确切的类型实参是未知的或不重要的时候，可以使用星号投影。