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

• 泛型方法

// 需要在调用方法时，指定具体类型
class MyGenericsMethod {
    // 定义一个泛型方法
    fun <T> method(param: T): T {
        return param
    }
}

val myIntMethod = MyGenericsMethod()
val myStringMethod = MyGenericsMethod()
println(myIntMethod.method<Int>(26))
println(myStringMethod.method<String>("Yang"))
// 打印结果
26
Yang

• 泛型属性

// 需要在创建对象时，指定具体类型
class MyGenericsProperty<T> {
    // 定义一个泛型属性
    var property: T? = null
}

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 关键字：协变
    • out 关键字用于声明一个泛型类型是协变的。这意味着你可以将该泛型类型用于返回值，但不能用于消费（即输入参数）。协变的类型参数可以安全地从子类型转换到父类型。例如，Producer<out T> 表示该类型只能作为生产者，它可以返回 T 或 T 的子类型的对象。协变的核心思想是“只生产，不消费”
  • in 关键字：逆变
    • in 关键字用于声明一个泛型类型是逆变的。逆变允许你将该泛型类型用于消费（即输入参数），但不能用于返回值。逆变的类型参数可以安全地从父类型转换到子类型。例如，Consumer<in T> 表示该类型只能作为消费者，它可以接收 T 或 T 的父类型的对象。逆变的核心思想是“只消费，不生产”
  • 星号投影 *
    • 是星号投影，用于表示未知类型。它的作用类似于 Java 中的 <? extends Object>，但在 Kotlin 中，它更类似于 out Any?。它表示该位置可以是任何类型

// 泛型上下界约束
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