本博文主要讲解一些Kotlin泛型的问题，中间会对比穿插Java泛型。

1. 泛型类型参数

1.1 形式

我们使用泛型的形式无非是类、借口、方法几种，我们先看两个例子。

1.2 声明泛型类

和Java一样，我们通过在类名后面添加一对<>，并把类型参数放在<>内来声明泛型类和泛型接口。

一旦声明完成，我们就可以在类和接口内部，像使用其他类型一样使用类型参数了。

我们来看下标准的Java接口List如何使用Kotlin来声明。 Kotlin中List接口的定义。

public interface List<out E> : Collection<E> {
  
    override val size: Int

    override fun isEmpty(): Boolean
    override fun contains(element: @UnsafeVariance E): Boolean
    override fun iterator(): Iterator<E>
    override fun containsAll(elements: Collection<@UnsafeVariance E>): Boolean
    public operator fun get(index: Int): E
    public fun indexOf(element: @UnsafeVariance E): Int
    public fun lastIndexOf(element: @UnsafeVariance E): Int
    public fun listIterator(): ListIterator<E>
    public fun listIterator(index: Int): ListIterator<E>
    public fun subList(fromIndex: Int, toIndex: Int): List<E>
}

如果你的类继承了泛型类(或者实现了泛型接口)，你就得为基础类型的泛型提供一个类型实参，它可以是一个具体的类型或者另外一个类型形参。

class StringList : List<String>{
	override fun get(index:Int):String =...
}

一个简单的泛型类定义：

class Pair<K, V>(key: K, value: V) {
    var key: K = key
    var value = value
}

1.3 泛型方法定义：

fun <T : Any> getClassName(clzObj: T): String {
    return clzObj.javaClass.simpleName
}

泛型T被声明在方法名前面。

泛型T默认为可空类型，并且我们限定了T继承Any,防止clzObj为空。

1.4 和Java泛型的不同之处

(1)和Java不同，Kotlin始终要求类型实参要么被显式的声明，要么能被编译器推到出来。

val readers : MutableList<String> = mutableListOf()
val readers = mutableListOf<String>()

上面这两行代码是等价的。

(2) Kotlin不支持原生类型

Kotlin一开始就有泛型，因此它不支持原生态类型，类型实参必须定义。

2. 类型参数约束

2.1 T上界指定

如果把一个类型指定为泛型类型形参的上界约束，在泛型具体的初始化时，其对应的泛型实参类型就必须为是这个具体类型或者其子类型。

Java中的形式： T extends Number

Kotlin中的形式： T : Number

fun <T : Number> List<T>.sum():T{
	//...
}

一旦指定了类型上界，你就可以在将T当做它的上界类型来使用。

如上面的例子，我们可以将T当作Number类型来使用。

2.2 为一个类型参数指定多个约束

fun <T> ensureTrailingPeriod(seq: T)
        where T : CharSequence, T : Appendable {
    //...
}

上面这个例子，指定了可以作为类型参数实参的类型必须实现了CharSequence和Appendable两个接口。

2.3 让类型形参非空

事实上，没有指定上界的类型形参将会使用Any?这个默认的上界。

看下面的这个例子：

class Processor<T> {
    fun process(value: T) {
        println(value?.hashCode())
    }
}

在process方法中，value是可空的，尽管T没有使用任何的？标记。

如果你想指定任何时候类型形参都是非空的，那么你可以通过指定一个约束来实现。

如果你除了可控性之外没有其他限制，可以使用Any代替默认的Any?作为其上界。

class Processor<T : Any> {
    fun process(value: T) {
        println(value.hashCode())
    }
}

注意：String?不是Any的子类型，它是Any?的子类型；String才是Any的子类型。

3. 运行时泛型

我们知道JVM上的泛型，一般是通过类型擦除来实现的，所以也被成为伪泛型，也就说类型实参在运行时是不保存的。

实际上，我们可以声明一个inline函数，使其类型实参不被擦除，但是这在Java中是不行的。

3.1 类型擦除

和Java一样，Kotlin的泛型在运行时也被擦除了，这意味着实例不会携带用于创建它的类型实参的信息。

例如你创建了一个List并将一堆字符串保存其中，在运行时你只能看到一个List,不能辨别出列表本打算包含的是哪种类型的元素。

看起来类型擦除是不安全的，但在我们编码的时候，编译器是知道类型实参的类型的，确保你只能添加合适类型的元素。

类型擦除的好处就是节省内存。

3.1.1 is

因为类型擦除的原因，所以一般情况下，在is检查中不可能使用类型实参的类型。 对应的Java中，不能在一个确定泛型上执行instanceof操作。

Kotlin不允许使用没有指定类型实参的泛型类型。 那么你可能想知道如何检查一个值是否为列表，而不是Set或者其他对象，可以使用特殊的星号投影语法来做这个检查。

fun <T : Any> process(value: T) {
    if (value is List<String>) {
        // error
    }

    if (value is List<*>) {
        // ok
    }

    var list = listOf<Int>(1, 2, 3)
    if (list is List<Int>) {
        // ok
    }
}

Kotlin的编译器是足够聪明的，如果在编译期已经知道相应的类型信息时，is检查是被允许的。

List<*>相当于Java中的List<?>,拥有某个未知类型实参的泛型类型。 上面的例子中只是检查了value是否为List，而没有得到关于它的元素类型的任何信息。

3.1.2 as/as?

在as和as?转换中，我们仍然可以使用一般的泛型类型。

(1)如果该类有正确的基础类型但类型实参是错误的，转换也不会失败，因为在运行时类型实参是未知的(因为被擦除掉了)，但是后面可能会出现ClassCastException。

(2)如果该类型基础类型都不正确的话，as？就会返回一个null值。

fun main(args: Array<String>) {
    var list: List<Int> = listOf(1, 2, 3)
    printSum(list)// 6

    var strList: List<String> = listOf("1", "2", "3")
    printSum(strList)// ClassCastException

    var intSet: Set<Int> = setOf(1, 2, 3)
    printSum(intSet) // IllegalStateException
}

fun printSum(c: Collection<*>) {
    val intList = c as? List<Int> ?:
            throw IllegalStateException("List is expected")
    println(intList.sum())
}

3.2 实化类型参数函数

泛型函数的类型实参，在运行时同样会被擦除。 只有一种特殊的情况：内联函数，内联函数的类型形参能够被实化，意味着在运行时，你可以引用实际的类型实参。

// compile error
fun <T> isA(value: Any) = value is T 

3.2.1 inline

如果使用inline标记函数，编译器会把每一次函数调用都替换为函数实际的代码。

lambda的代码也会被内联，不会创建任何匿名内部类。

inline函数大显身手的另一种场景：他们的类型参数可以被实化。

3.2.2 实化参数函数

inline fun <reified T> isA(value: Any) = value is T

一个实际的例子filterIsInstance：

public inline fun <reified R> Iterable<*>.filterIsInstance(): List<@kotlin.internal.NoInfer R> {
    return filterIsInstanceTo(ArrayList<R>())
}

public inline fun <reified R, C : MutableCollection<in R>> Iterable<*>.filterIsInstanceTo(destination: C): C {
    for (element in this) if (element is R) destination.add(element)
    return destination
}

简化Android的startActivity方法：

inline fun <reified T : Activity> Context.startActivity() {
    val intent = Intent(this,T::class.java)
    startActivity(intent)
}

3.2.2 为什么实化只对inline函数有效

这是什么原理呢？为什么inline函数中可以这样写element is R,而普通的函数不行呢？

正如之前描述的，编译器把实现inline行数的字节码插入到每一次调用发生的地方。 每次你调用带实例化类型参数的inline方法时，编译器都知道这次特定调用中用作类型实参的确切类型，因此编译器可以生成引用实际类型的字节码。

实化类型参数的inline函数不能在Java中调用，普通的内联函数可以在Java中被调用。

4. 变型：泛型和子类型化

4.1 子类和子类型

Int是Number的子类。

Int类型是Int?类型的子类型，他们都对应Int类。

一个非空类型是它的非空版本的子类型，但他们都对应同一个类。

List是一个类，List\List是类型。

明白子类和子类型很重要。

4.2 不变型

一个泛型类，例如MutableList--如果对于任意的两个类型A和B，Mutable既不是Mutable的父类型，也不是它的父类型，那么该泛型类就称为在该类型参数是不变型。

interface Producer<out T> {
    fun produce(): T
}

open class Animal {
    open fun feed() {
        println("Animal is feeding.")
    }
}

class Herd<T : Animal> {
    val size: Int = 10
    fun get(index: Int): Animal? {
        return null
    }
}

fun feedAllAnimal(animals: Herd<Animal>) {
    for (i in 0 until animals.size) {
        animals.get(i)?.feed()
    }
}

class Cat : Animal() {
    override fun feed() {
        println("Cat is feeding.")
    }
}


fun takeCareOfCats(cats: Herd<Cat>) {
    feedAllAnimal(cats)//comile error
}

class Herd<out T : Animal> {
    val size: Int = 10
    fun get(index: Int): Animal? {
        return null
    }
}

public interface List<out E> : Collection<E>{
	//....
}

public interface MutableList<E> : List<E>, MutableCollection<E>{
	override fun add(element: E): Boolean
	public fun removeAt(index: Int): E
}

// compile error
class Herd<out T : Animal>(var leadAnimal: T) {
    
}

// ok
class Herd<out T : Animal>(private var leadAnimal: T) {
    
}

fun <T : R, R> copyTo(source: MutableList<out T>, destination: MutableList<in T>) {
    source.forEach { item -> destination.add(item) }
}