Kotlin的泛型

泛型的概念

• 泛型是一种类型层面的抽象
• 泛型通过泛型参数实现构造更加通用的类型的能力
• 泛型可以让符合继承关系的类型批量实现某些能力

download.jpg

// 源码实现, 比较数字的大小,使用泛型代替Any
// inline内联函数
// actual 跨平台类型
public actual fun <T : Comparable<T>> maxOf(a: T, b: T): T {
    return if (a >= b) a else b
}

如上,我要两者的比较大小,比较的元素限制在Comparable的实现类

任意类型的列表

sealed class List<T> {

// Nothing 是所有类型的子类
    object Nil : List<Nothing>() {
        override fun toString(): String {
            return "Nil"
        }
    }

    class Cons<T>(val head: T, val tail: List<T>) : List<T>() {
        override fun toString(): String {
            return "$head,$tail"
        }
    }
}

泛型的基本声明方法

• 函数声明泛型
  fun <T> f()
• 类声明泛型
  class Node<T>

添加类型的约束

fun <T : Comparable<T>> maxOf(a: T, b: T): T {
    return if (a > b) a else b;
}

注: 必须传入Comparable的实现类T,并返回T

新特性where: 定义多个约束, 这个类似java 中extend a & b

fun <T> callMax(a: T, b: T)
        where T : Comparable<T>, T : () -> Unit {
    return if (a > b) a() else b();
}

// 多参数,多约束
fun <T, R> callMax(a: T, b: T):R
        where T : Comparable<T>, T : () -> R, R : Number {
    return if (a > b) a() else b();
}

总结: 其实kt的泛型和Java类似,就是多约束的时候增加了where关键字

泛型的型变

• 泛型实参的继承关系对泛型类型的继承关系的影响

泛型型变:
协变: 继承关系一致
逆变: 继承关系相反
不变: 没有继承关系

• 协变out T 说明要发出去的,所以有getter

// 加入了 `out T` 后,可以    B<夫> b=A<子>() 这种写法,并且能否返回 T(夫的实例)
// 类似于Java 的 extend T
sealed class List<out T> {
    object Nil : List<Nothing>() {
        override fun toString(): String {
            return "Nil"
        }
    }

    class Cons<T>(val head: T, val tail: List<T>) : List<T>() {
        override fun toString(): String {
            return "$head,$tail"
        }
    }
}

逆变in T说明要传进来的,需要setter

open class Waste {
}
// out extend out get
// in super in setter
class DryWaste() : Waste() {

}

// 使用的时候限制输入的值
// waste 可以放在 垃圾 或者干垃圾箱
// dryWaste 只能放在干垃圾箱

// 所以在 dryWaste 是父类.
// 干垃圾
class Dustbin<in T : Waste> {
    fun put(t: T) {
        TODO()
    }
}


fun contravariant() {

    val dustbin1 = Dustbin<Waste>()
    val dustbin2 = Dustbin<DryWaste>()

    val waste = Waste()
    val dryWaste = DryWaste()

    dustbin1.put(waste);
    dustbin1.put(dryWaste);

    //逆变
//    dustbin2.put(waste);
    dustbin2.put(dryWaste);
}

out :父类 协变 向外输出,相当于extend
in :子类 逆变 向内输入,相当于super

违反型变约束 @UnsafeVariance T

本来协变后,是不能作为参数传入的

违反型变约束:

• 声明为协变的类出现逆变点,或者相反
• 声明为不变的类接受 逆变或者协变的类型参数

安全前提:

sealed class List<out T>
{
  operate fun cont
}