泛型

Kotlin中的泛型源自于Java，但同时也做了一些强化。

/**
 * 泛型接口
 */
interface Generator<T> {
    fun next(): T
    fun print(t: T)
}

/**
 * 定义具体的类
 */
class ChainLine {
    val value: Int = 8
}

class ChainLineGenerator(val index: Int) : Generator<ChainLine> {
    override fun next(): ChainLine {
        println("index:$index")
        return ChainLine()
    }

    override fun print(t: ChainLine) {
        println("index:$index, value:${t.value}")
    }
}

/**
 * 泛型类
 */
abstract class Color<T>(var t: T) {
    abstract fun print()
}

class Red {
    val color: String = "red"
}

class RedColor(t: Red) : Color<Red>(t) {
    override fun print() {
        println("color: ${t.color}")
    }
}

/**
 * 泛型方法
 */
fun <T> print(name: String, tclazz: Class<T>): T? {
    val t: T? = tclazz.newInstance()
    return t
}

/**
 * 泛型约束
 * T: Comparable 等同于 T extends Comparable
 * Comparable<T> 等同于 Comparable<T super ?>
 */
fun <T: Comparable<T>?> sort(list: List<T>?): Unit {
}

fun main() {
    // 泛型接口
    val chainLineGenerator = ChainLineGenerator(1)
    chainLineGenerator.print(chainLineGenerator.next())

    // 泛型类
    RedColor(Red()).print()

    // 泛型方法
    println(Red::class.java)

    // 泛型约束，如果这里传递listOf<Int>(Red(), Red())就会报错
    // 泛型了解到这一步已经够了，至于什么out协变和in逆变，可以在后续工作中慢慢了解
    val list = listOf<Int>(3, 2, 5, 6)
    sort(list)
    println(list)
}

---

感谢支持

更多内容，请移步《超级个体》。