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