Kotlin-＞Kotlin泛型

泛型

• 泛型类

// 需要在创建对象时，指定具体类型
class MyGenericsClass<T> {
    fun method(param: T): T {
        return param
    }
}
val myIntClass = MyGenericsClass<Int>()
val myStringClass = MyGenericsClass<String>()
println(myIntClass.method(26))
println(myStringClass.method("Yang"))
// 打印结果
26
Yang

• 泛型方法

// 需要在调用方法时，指定具体类型
val myIntMethod = MyGenericsMethod()
val myStringMethod = MyGenericsMethod()
println(myIntMethod.method<Int>(26))
println(myStringMethod.method<String>("Yang"))
// 打印结果
26
Yang

• 泛型属性

// 需要在创建对象时，指定具体类型
val myIntProperty = MyGenericsProperty<Int>().apply { property = 26 }
val myStringProperty = MyGenericsProperty<String>().apply { property = "Yang" }
println(myIntProperty.property)
println(myStringProperty.property)
// 打印结果
26
Yang

• 一般泛型约束:和where

// 泛型约束
class MyConstraint {
    // 单重约束，T 必须是 Number 的子类或者 Number，约束条件在<>中
    fun <T : Number?> method(param: T): T = param
    // 多重约束，T 必须是 Number 的子类或者 Number，同时必须是 Comparable 的子类，约束条件在where中
    fun <T> method(param: T) where T : Number, T : Comparable<T> = param
}

• 上下界泛型约束out和in
• <out T>声明的泛型类，T只能做返回类型，因为<out T>能确定返回类型一定是T的子类，T作为保底返回类型使用，但T作为类型参数的话，所使用泛型的具体类型不知道是T的某一个子类
• <in T>声明的泛型类，T只能做类型参数，因为<in T>能确定类型参数一定是T的父类，T作为保底类型参数使用，但T作为返回类型的话，所使用泛型的具体类型不知道是T的某一个父类
• <*>号，相当于<out Any>，对比与Java的<? extends Object>

// 泛型上下界约束
class MyArrayList<T> {}
var myNumerArrayList = MyArrayList<Number>()
var myIntArrayList = MyArrayList<Int>()
// myIntArrayList 和 myNumerArrayList不能互相赋值，Int虽然是Number的子类，但作为泛型传递后，父子类关系失效

// 泛型上界约束 子类型的泛型可以赋值给父类型的泛型
class MyArrayList<out T> {}
myNumerArrayList = myIntArrayList 

// 泛型下界约束 父类型的泛型可以赋值给子类型的泛型
class MyArrayList<in T> {}
myIntArrayList = myNumerArrayList

// 协变<out T> 对应java < ? extends T>，生产者，泛型类型只能作为返回值
interface Producer<out T>{
    fun get() : T
    fun set(t: T) //编译报错
}
// 逆变<in T> 对应java < ? super T>，消费者，泛型类型只能作为方法参数
interface Consumer<in T>{
    fun set(t: T)
    fun get() : T // 编译报错
}
var list: List<*> ?= null

• reified关键字

// 运行时获取具体泛型类型
inline fun <reified T> check(value: Any?) {
    if (value is T) {
        println("和T类型匹配")
    } else {
        println("和T类型不匹配")
    }
}
check<Int>(26)
check<Int>("Yang")

// 打印结果
和T类型匹配
和T类型不匹配
// 运行时获取具体Kotlin类型
inline fun <reified T : Any> getClass(): KClass<T> {
    return T::class
}
// 运行时获取具体Java类型
inline fun <reified T : Any> getJavaClass(): Class<T> {
    return T::class.java
}
println(getClass<String>())
println(getJavaClass<String>())
// 打印结果
class java.lang.String 
class java.lang.String