【Kotlin -- 知识点】泛型

一、前言

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

1. 什么是泛型？
泛型通俗的理解就是：很多的类型，它通过使用参数化类型的概念，允许我们在不指定具体类型的情况下进行编程

2. 泛型有什么作用？
泛型是 JDK 1.5 引入的安全机制，是一种给编译器使用的技术：

• 提高了代码的可重用性
• 将运行期的类型转换异常提前到了编译期，保证类型的安全，避免类型转换异常

3. 怎么去定义和使用泛型？
我们可以给一个类，方法，或者接口指定泛型，在具体使用的地方指定具体的类型

先了解一下 【Java – 基础】深入探索 – 泛型

二、泛型的基本用法

//1、定义一个泛型类，在类名后面使用 <T> 这种语法结构就是为这个类定义一个泛型
class MyClass<T>{
  	fun method(params: T) {
      
    }
}
//泛型调用
val myClass = MyClass<Int>()
myClass.method(12)

//2、定义一个泛型方法，在方法名的前面加上 <T> 这种语法结构就是为这个方法定义一个泛型
class MyClass{
    fun <T> method(params: T){

    }
}

//泛型调用
val myClass = MyClass()
myClass.method<Int>(12)
//根据 Kotlin 类型推导机制，我们可以把泛型给省略
myClass.method(12)

//3、定义一个泛型接口，在接口名后面加上 <T> 这种语法结构就是为这个接口定义一个泛型
interface MyInterface<T>{
    fun interfaceMethod(params: T)
}

对比 Java 中定义泛型，在定义类和接口泛型上没有任何区别，在定义方法泛型时，Kotlin 是在方法名前面添加泛型，而 Java 是在返回值前面添加泛型。

1. 定义泛型接口

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}")
    }

}

2. 定义泛型类

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}")
    }

}

3. 定义泛型方法

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> {}