Kevin Learn Kotlin：泛型

每日一图.jpg

Kotlin 的泛型与 Java 一样，都是一种语法糖。泛型其实就是把类型参数化，它的引入给强类型编程语言加入了更强的灵活性。

泛型接口

fun main() {
    val study = Student()
    study.doHomework("math")
    println("阅读：${study.readBook()}")
}

interface Study<T> {
    fun readBook():T
    fun doHomework(t: T)
}

class Student : Study<String> {
    override fun readBook(): String {
        return "《红楼梦》"
    }

    override fun doHomework(t: String) {
        println("doHomework:${t}")
    }

}

泛型类

fun main() {
    val green = GreenColor("绿色")
    green.printColor()
}

abstract class Color<T>(var t: T){
    abstract fun printColor()
}

class GreenColor(var color: String):Color<String>(color) {
    override fun printColor() {
        println("打印颜色：${color}")
    }

}

泛型方法

fun main() {
    fromJson("{}", String::class.java)
}

fun <T> fromJson(json: String,clazz: Class<T>) : T? {
     val instance = clazz.newInstance()
    return instance
}

泛型约束

• 约束泛型类

fun main() {
    fromJson<JSONObject>("{}",JSONObject::class.java)
}

// 泛型类型限定-1
// 所传递的类型 T 必须满足是 JSONObject的子类 或 JSONObject 类
fun <T : JSONObject> fromJson(json: String,clazz: Class<T>) : T? {
     val instance = clazz.newInstance()
    return instance
}

• 同时约束泛型类和接口

fun main() {
    fromJson<User>("{}",User::class.java)
}

// 泛型类型限定-2
// 所传递的类型 T 必须满足 where 语句的所有条件
// 在下面的示例代码中，类型 T 必须是 JSONObject的子类 或 JSONObject 类，也实现了 Comparable
fun <T> fromJson(json: String,clazz: Class<T>) : T? where T : JSONObject,T : Comparable<T>{
     val instance = clazz.newInstance()
    return instance
}

class User : JSONObject(),Comparable<User> {
    override fun compareTo(other: User): Int {
        return 0
    }
}

泛型中的 out 与 in

• out 约束泛型参数的类型上限

open class Animal

open class Dog : Animal()

class Cat : Animal()

class BlackDog : Dog()

fun select() {
    val animal = Dog()

    // 传入的泛型参数可以是 Animal 及 Animal 的子类 Dog Cat BlackDog
    // 方式一 在使用处使用out 关键字声明--泛型上限
    val list:ArrayList<out Animal> = ArrayList<Dog>()

    val list2:ArrayList<Animal> = ArrayList<Dog>()
}

//方式二 在定义处使用 out 关键字声明，允许传入的泛型参数可以是 T or T 的子类--泛型上限
class ArrayList<out T> {}

• in 约束泛型参数的类型下限

open class Animal

open class Dog : Animal()

class Cat : Animal()

class BlackDog : Dog()

fun select() {
    val animal = Dog()

    // 传入的泛型参数可以是 Animal 及 Animal 的子类 Dog Cat BlackDog
    // 方式一 在使用处使用in 关键字声明--泛型下限
    val list:ArrayList<in Dog> = ArrayList<Animal>()

    val list2:ArrayList<Dog> = ArrayList<Animal>()
}

//方式二 在定义处使用 in 关键字声明，允许传入的泛型参数可以是 T or T 的父类--泛型下限
class ArrayList<in T> {}