kotlin学习笔记 20210303

kotlin学习笔记-2

泛型的高级特性

1）对泛型进行实化

fun foo() {
    bar<Int>()
}

/**
 * 内联函数
 */
inline fun <T> bar() {
    // do something with T type
}

代码编译后：
fun foo() {
    // do something with Int type
}

bar()是一个带泛型的内联函数，foo()函数调用了bar()函数，代码编译后，bar()函数中代码获得泛型的实际类型 ------------------ 表明kotlin中可以将内联函数中的泛型进行实化
如何泛型实化：首先必须是内联函数（inline关键字修饰的函数），其次声明泛型的地方必须加上reified关键字表示该泛型要进行实化：

inline fun <reified T> getGenericType(){
}

如何泛型实化：首先必须是内联函数（inline关键字修饰的函数），其次声明泛型的地方必须加上reified关键字表示该泛型要进行实化

泛型实化的作用，例：

/**
 * @return Class<T> 获取泛型实际类型
 */
inline fun <reified T> getGenericType() = T::class.java

2）泛型实化的应用

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

startActivity<TestActivity>(context)

inline fun <reified T> startActivity(context: Context, block: Intent.() -> Unit) {
    val intent = Intent(context, T::class.java)
    intent.block()
    context.startActivity(intent)
}

startActivity<MainActivity>(context){
    putExtra("name","泛型实化")
}

inline fun <reified T> bindService(context: Context, connection: ServiceConnection) {
    val intent = Intent(context, T::class.java)
    context.bindService(intent, connection, Context.BIND_AUTO_CREATE)
}
inline fun <reified T> stopService(context: Context) {
    val intent = Intent(context, T::class.java)
    context.stopService(intent)
}
inline fun <reified T> startService(context: Context) {
    val intent = Intent(context, T::class.java)
    context.startService(intent)
}
inline fun <reified T> startService(context: Context, block: Intent.() -> Unit) {
    val intent = Intent(context, T::class.java)
    intent.block()
    context.startService(intent)
}

3）泛型的协变

假如定义了一个 MyClass<T> 的泛型类，其中 A 是 B 的子类型，同时 MyClass<A> 又是 MyClass<B> 的子类型，那么我们就可以称 MyClass 在 T 这个泛型上是协变的

open class Person(val name: String, val age: Int)
class Student(name: String, age: Int, score: Double? = 0.0) : Person(name, age)
class Teacher(name: String, age: Int, course: String? = "") : Person(name, age)

class SimpleData<out T>(val data: T?) {
    fun get(): T? = data
}

fun main() {
    val student = Student("Jim", 18, 99.0)
    val data = SimpleData(student)
    handleSimpleData(data)
    val studentData = data.get()
}

fun handleSimpleData(data: SimpleData<Person>) {
    val person = data.get()
}

可参照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>
}

4）泛型的逆变

假如定义了一个 MyClass<T> 的泛型类，其中 A 是 B 的子类型，同时 MyClass<B> 又是 MyClass<A> 的子类型，那么我们就可以称 MyClass 在 T 这个泛型上是逆变的

interface Transformer<in T> {
    fun transformer(t: T): String
}

fun main() {
    val trans = object : Transformer<Person> {
        override fun transformer(t: Person): String {
            return "${t.name} ${t.age}"
        }
    }
    handleTransformer(trans)// 代码报错
}

fun handleTransformer(transformer: Transformer<Student>) {
    val student = Student("Tom", 19)
    val result = transformer.transformer(student)
    println(result)
}

可参照Comparable源码：
public interface Comparable<in T> {
    public operator fun compareTo(other: T): Int
}

5）@UnsafeVariance 可以打破 协变/逆变 语法规则，但需慎用