与Java一样，Kotlin也支持泛型，为类型安全提供保证，消除类型强转的烦恼
class User<T>{
var type :T ?=null
}
创建类的实例时我们需要指定类型参数:
val box: Box<Int> = Box<Int>(1)
// 或者
val box = Box(1) // 编译器会进行类型推断，1 类型 Int，所以编译器知道我们说的是 Box<Int>。
定义泛型类型变量，可以完整地写明类型参数，如果编译器可以自动推定类型参数，也可以省略类型参数。
型变
在此之前，我们先来看一看Java中的通配符。
首先，Java中的泛型是不型变的，这意味着 List<String> 并不是 List<Object> 的子类型。这是因为Java中如果可以型变，那么就会出现如下：
public static void main(String [] args){
//Java
List<String> strs = new ArrayList<>();
List<Object> objs = strs;//编绎器报错
//如果不报错，我们可以
objs.add(1);//将整数放入字符串集合中
String s = strs.get(0);//!!!ClassCastException 无法将整型转为字符串
}
因此，Java 禁止这样的事情以保证运行时的安全。但这样会有一些影响：比如将String类型 的集合添加到Object类型的集合中,因为String是Object的子类，这个操作其实是完全安全的。
但是我们看到Java源码中是这样定义的：
// Java
interface Collection<E> …… {
void addAll(Collection<? extends E> items);
}
我们将它改成这样的话：
// 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的通配符类型参数 {? extends E} 表示此方法接受 E 或者 E 的 一些子类型对象的集合，而不只是 E 自身。这意味着我们可以安全地从其中（该集合中的
元素是 E 的子类的实例）读取 E ，但不能写入，因为我们不知道什么对象符合那个未知的 E 的子类型。反过来，该限制可以让 Collection<String> 表示为 Collection<? extends Object> 的子类型。简而言之，带extends限定（上界）的通配符类型使得类型是协变的（covariant）。
在来看下面一段代码：
public void genericCode(){
//Java
List<? extends String> texts = new ArrayList<>();
texts.add("dd");//出错--不可写
String s = texts.get(0);//可读
List<? super String> spans = new ArrayList<>();
spans.add("ddddd");//可以写入
String s = spans.get(0);//出错--不可读
}
理解为什么这个技巧能够工作的关键相当简单：如果只能从集合中获取项目，那么使用String 的集合，并且从其中读取Object也没问题。反过来，如果只能向集合中放入项目，就可以用Object 集合并向其中放入 String ：在 Java 中 List<? super String> 是 List<Object> 的一个超类。后者称为逆变性（contravariance）
但是在Kotlin中并没有通配符这种东西，但是它有：
- 声明处型变 （declaration-site variance）
- 类型投影 （type projections）
声明处型变
声明处的类型变异使用协变注解修饰符：in、out，消费者 in, 生产者 out。
使用 out 使得一个类型参数协变，协变类型参数只能用作输出，可以作为返回值类型但是无法作为入参的类型：
// 定义一个支持协变的类
class Runoob<out A>(val a: A) {
fun foo(): A {
return a
}
}
fun main(args: Array<String>) {
var strCo: Runoob<String> = Runoob("a")
var anyCo: Runoob<Any> = Runoob<Any>("b")
anyCo = strCo
println(anyCo.foo()) // 输出 a
}
in 使得一个类型参数逆变，逆变类型参数只能用作输入，可以作为入参的类型但是无法作为返回值的类型:
// 定义一个支持逆变的类
class Runoob<in A>(a: A) {
fun foo(a: A) {
}
}
fun main(args: Array<String>) {
var strDCo = Runoob("a")
var anyDCo = Runoob<Any>("b")
strDCo = anyDCo
}
下面有两个与Java对照的实例，可以加深这种理解
//Kotlin
interface Source<out T>{
fun data():Source<T>
}
class DataSource :Source<Any>{
val source :Source<String>= ...
override fun data(): Source<Any> {
return source;
}
}
//Java
interface Source<T>{
Source<T> data();
}
class DataSource implements Source<Object>{
Source<String> source = null;
@Override
public Source<Object> data() {
return source;//!!!不允许，抛错
}
}
再来：
//Kotlin
interface Box<in T>{
fun set(t:T)
}
fun doIt(box:Box<Number>){
box.set(1.0)//1.0 拥有类型 Double，它是 Number 的⼦类型
// 因此，我们可以将 box 赋给类型为 Box <Double> 的变量
var dBox :Box<Double> = box
}
//Java
interface Box<T>{
void set(T t);
}
void doIt(Box<Number> box){
box.set(1.0);
Box<Double> dBox = box;//!!!IDE提示出错
}
类型投影
Kotlin中有时也会遇到跟Java一样的尴尬，很好的例子就是 Array，我们来看看 Array 的源码：
public class Array<T> {
...
}
很明显，该类在 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>)
因为 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 提供了一种语法, 称为 星号投影(star-projection):
- 假如类型定义为 Foo<out T> , 其中 T 是一个协变的类型参数, 上界(upper bound)为 TUpper ,Foo<*> 等价于 Foo<out TUpper> . 它表示, 当 T 未知时, 你可以安全地从 Foo<*> 中 读取TUpper 类型的值.
- 假如类型定义为 Foo<in T> , 其中 T 是一个反向协变的类型参数, Foo<*> 等价于 Foo<in Nothing> . 它表示, 当 T 未知时, 你不能安全地向 Foo<*> 写入 任何东西.
- 假如类型定义为 Foo<T> , 其中 T 是一个协变的类型参数, 上界(upper bound)为 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?> .
Note :星号投射与 Java 的原生类型(raw type)非常类似, 但可以安全使用
泛型函数
不仅类可以有类型参数。函数也可以有。类型参数要放在函数名称之前：
fun <T> singletonList(item: T): List<T> {
// ……
} f
un <T> T.basicToString() : String { // 扩展函数
// ……
}
要调用泛型函数，在调用处函数名之后指定类型参数即可：
val l = singletonList<Int>(1)
泛型约束
能够替换给定类型参数的所有可能类型的集合可以由泛型约束限制。
上界
最常见的约束类型是与 Java 的 extends 关键字对应的 上界：
fun <T : Comparable<T>> sort(list: List<T>) {
// ……
}
冒号之后指定的类型是上界：只有 Comparable<T> 的⼦类型可以替代 T 。例如：
sort(listOf(1, 2, 3)) // OK。Int 是 Comparable<Int> 的⼦类型
sort(listOf(HashMap<Int, String>())) // 错误：HashMap<Int, String> 不是 Comparable<HashMap<Int, String>> 的子
类型
默认的上界（如果没有声明）是 Any? 。在尖括号中只能指定一个上界。如果同一类型参数需要多个上界，我们需要一个单独的 where-子句：
fun <T> cloneWhenGreater(list: List<T>, threshold: T): List<T> where T :Comparable,T : Cloneable {
return list.filter { it > threshold }.map { it.clone() }
}
