【Kotlin】泛型总结 ★ ( 泛型类 | 泛型参数 | 泛型函数 | 多泛型参数 | 泛型类型约束 | 可变参数结合泛型 | out 协变 | in 逆变 | reified 检查泛型参数类型 )

韩曙亮

发布于 2023-03-30 19:00:57

4.1K00

代码可运行

文章被收录于专栏：韩曙亮的移动开发专栏韩曙亮的移动开发专栏

运行总次数：0

代码可运行

文章目录

一、泛型类

定义一个泛型类 ,

将泛型参数 T 放在尖括号 <T> 中 , 该泛型参数放在类名后 , 主构造函数之前 , 该泛型参数 T 是类型占位符 ,

在该泛型类类中可以使用类型占位符 T 作为一个类使用 ,

可以定义 T 类型成员属性
主构造函数中可以接收 T 类型的实例对象作为参数 ,
T 类型可以作为函数的返回值 ;

通常情况下 , 泛型参数都使用 T 表示 , 使用其它字母或者字符串都可以表示泛型参数 , 但是约定俗成都使用 T 来表示泛型 ;

代码示例 : 下面的代码中 , 声明了 Student 泛型类 , 该泛型类接收 T 类型的泛型参数 , 在主构造函数中接收 T 类型的参数 , 在该泛型类中声明了 T 类型的成员属性 ;

class Student<T>(_item: T) {
    var item: T = _item
    fun log(){
        println("item : $item")
    }
}

fun main() {
    var student: Student<String> = Student("Tom")
    student.log()

    var student2: Student<Int> = Student(18)
    student2.log()
}

执行结果 :

item : Tom
item : 18

二、泛型参数

通常情况下 , 泛型参数都使用 T 表示 , 使用其它字母或者字符串都可以表示泛型参数 , 但是约定俗成都使用 T 来表示泛型 ;

在下面的代码中 , 使用 M 作为泛型参数 ;

代码示例 :

class Student<M>(_item: M) {
    var item: M = _item
    fun log(){
        println("item : $item")
    }
}

fun main() {
    var student: Student<String> = Student("Tom")
    student.log()

    var student2: Student<Int> = Student(18)
    student2.log()
}

执行结果 :

item : Tom
item : 18

三、泛型函数

函数的参数或返回值类型为泛型类型 , 则该函数称为泛型函数 ;

代码示例 : 该代码中 , 泛型函数 logT 的参数和返回值都是 T 泛型参数类型 ;

class Student<T>(_item: T) {
    var item: T = _item

    // 泛型函数 参数 和 返回值 都是 T 类型
    fun logT(t: T): T{
        println("item : $item")
        return item
    }
}

fun main() {
    var student: Student<String> = Student("Tom")
    println(student.logT(student.item))

    var student2: Student<Int> = Student(18)
    println(student2.logT(student2.item))
}

执行结果 :

item : Tom
Tom
item : 18
18

四、多泛型参数

泛型函数中如果涉及到匿名函数参数 , 匿名函数的参数返回值都是泛型的话 , 在该泛型函数中可能需要使用多个泛型 , 使用不同的字母表示不同的泛型 ;

如果函数中引入了新的泛型类型 , 需要在 fun 关键字和函数名之间 , 使用尖括号 <T> 注明 ;

代码示例 : 在本代码中 , logT 函数涉及到了两个泛型参数 , 传入的匿名函数参数类型为 (T) -> R , 需要两个泛型参数来表示其类型 ; T 类型在泛型类中注明 , 可以在该泛型类 Student 中随意使用 , 但是泛型参数 R 是首次在该函数中使用 , 因此需要在该函数的 fun 关键字和函数名之间 , 使用尖括号 <R> 注明新的泛型参数 ;

class Student<T>(_item: T) {
    var item: T = _item

    fun <R> logT(action: (T) -> R): R{
        return action(item)
    }
}

fun main() {
    var student: Student<String> = Student("Tom")
    println(student.logT {3.14})

    var student2: Student<Int> = Student(18)
    println(student2.logT {true})
}

执行结果 :

student 实例对象中 , 泛型 T 的实际类型是 String 类型 , 在 logT 中泛型 R 的类型是 Double 类型 ;
student2 实例对象中 , 泛型 T 的实际类型是 Int 类型 , 在 logT 中泛型 R 的类型是 Boolean 类型 ;

3.14
true

五、泛型类型约束

在泛型类 , 泛型函数中 , 使用泛型前 , 需要声明泛型参数 :

泛型类泛型参数声明 : 如果类中引入了新的泛型类型 , 需要在 class 关键字和主构造函数之前 , 使用尖括号 <T> 注明 ;

class Student<T>(_item: T) {
}

泛型函数泛型参数声明 : 如果函数中引入了新的泛型类型 , 需要在 fun 关键字和函数名之前 , 使用尖括号 <T> 注明 ;

    fun <R> logT(action: (T) -> R): R{
        return action(item)
    }

在尖括号 <> 中声明泛型参数时 , 可以指定泛型类型的约束 , 如泛型类型必须是某个类型的子类 ;

在下面的代码中 , Soldier 类的泛型进行了约束 , 必须是 Weapon 类的子类类型 ;

class Soldier<T : Weapon>(_item: T) {}

Weapon 类是父类 , 其有一个子类 AK47 类 ;

在创建 Soldier 实例对象时 , 传入子类 AK47 类的实例对象 , 调用其重写父类的 fire 函数 ;

代码示例 :

class Soldier<T : Weapon>(_item: T) {
    var item: T = _item

    fun fight(){
        item.fire()
    }
}

open class Weapon(var name: String){
    open fun fire(){
        println("weapon fire!")
    }
}
class AK47: Weapon("AK47"){
    override fun fire(){
        super.fire()
        println("fire in the hole !")
    }
}

fun main() {
    var soldier: Soldier<AK47> = Soldier(AK47())
    soldier.fight()
}

执行结果 :

weapon fire!
fire in the hole !

六、可变参数 vararg 关键字与泛型结合使用

如果泛型类型 T 的参数是 vararg 可变参数 , 则在接收可变参数时 , 需要使用 Array<out T> 类型的变量进行接收 ;

参数为 vararg 可变参数 , 那么可以传入多个指定类型的实例对象 ;

在下面的代码中 , 声明了泛型参数 T , T 类型不必须是 Weapon 类的子类类型 ;

在 Soldier 的主构造函数中 , 传入了泛型 T 类型的可变参数对象 ;

如果要使用成员属性接收该泛型 T 类型的可变参数对象 , 则必须使用 Array<out T> 类型对象进行接收 ;

代码示例 :

class Soldier<T : Weapon>(vararg _items: T) {
    var items: Array<out T> = _items

    fun fight(){
        for (item in items) {
            item.fire()
        }
    }
}

open class Weapon(var name: String){
    open fun fire(){
        println("weapon fire !")
    }
}
class AK47: Weapon("AK47"){
    override fun fire(){
        super.fire()
        println("AK47 fire fire !")
    }
}
class T72: Weapon("T72"){
    override fun fire(){
        super.fire()
        println("T72 fire fire !")
    }
}

fun main() {
    var soldier: Soldier<Weapon> = Soldier(AK47(), T72())
    soldier.fight()
}

执行结果 :

weapon fire!
AK47 fire fire !
weapon fire!
T72 fire fire !

七、使用 [] 运算符获取指定可变参数对象

如果想要使用 [] 运算符获取指定可变参数对象 , 就需要重写该类的 get 函数进行运算符重载 ;

如果想要通过 Soldier 实例对象 以 [] 运算符获取其 items: Array<out T> 中的某个元素 , 则需要重写该类的 get 方法 ;

    var items: Array<out T> = _items

    operator fun get(index: Int): T? {
        return items[index]
    }

之后使用 soldier[0] 即可获取 items 可变参数中的实例对象 ;

    var soldier: Soldier<Weapon> = Soldier(AK47(), T72())
    soldier[0]?.fire()
    soldier[1]?.fire()

代码示例 :

class Soldier<T : Weapon>(vararg _items: T) {
    var items: Array<out T> = _items

    operator fun get(index: Int): T? {
        return items[index]
    }

    fun fight(){
        for (item in items) {
            item.fire()
        }
    }
}

open class Weapon(var name: String){
    open fun fire(){
        println("weapon fire !")
    }
}
class AK47: Weapon("AK47"){
    override fun fire(){
        super.fire()
        println("AK47 fire fire !")
    }
}
class T72: Weapon("T72"){
    override fun fire(){
        super.fire()
        println("T72 fire fire !")
    }
}

fun main() {
    var soldier: Soldier<Weapon> = Soldier(AK47(), T72())
    soldier[0]?.fire()
    soldier[1]?.fire()
}

执行结果 :

weapon fire!
AK47 fire fire !
weapon fire!
T72 fire fire !

八、泛型 out 协变

使用 out 关键字 , 可以使子类泛型对象赋值给父类泛型对象 ;

在泛型类中 , 如果只将泛型类型作为函数的返回值类型 , 则在声明泛型参数类型时 , 在泛型参数前使用 out 关键字 , 同时该泛型类又称为生产类 ( 生产接口 ) , 用于生产泛型类指定的泛型对象 ;

代码示例 : 在下面的接口中 , 泛型类型只用于作为返回值 ;

interface Producer<out T> {
    fun produce(): T
}

九、泛型 in 逆变

使用 in 关键字 , 可以使父类泛型对象赋值给子类泛型对象 ;

在泛型类中 , 如果只将泛型类型作为函数的参数类型 , 则在声明泛型参数类型时 , 在泛型参数前使用 in 关键字 , 同时该泛型类又称为消费类 ( 消费接口 ) , 用于消费泛型类指定的泛型对象 ;

代码示例 : 在下面的接口中 , 泛型类型只用于作为参数 ;

interface Consumer<in T> {
    fun consume(t: T)
}

十、泛型 invariant 不变

在泛型类中 , 如果

既将泛型类型作为函数的参数类型 ,
又将泛型类型作为函数的返回值类型 ,

则在声明泛型参数类型时 , 既不使用 in 关键字 , 又不使用 out 关键字 ;

代码示例 : 在下面的接口中 , 泛型类型即用于作为返回值 , 又用于作为参数 ;

interface ProducerOrConsumer<T> {
    fun produce(): T
    fun consume(t: T)
}

十一、泛型逆变协变代码示例

泛型类中泛型参数有子类和父类 ,

Java 语言中 , 泛型参数是子类的泛型类对象 , 不可以赋值给泛型参数是父类的变量 ;
- Java 中的泛型对象赋值 , 不存在继承关系 , 是什么类型就是什么类型 , 类型要严格相同 ;

import java.util.ArrayList;

public class HelloAWT {
    public static void main(String[] args) {
        ArrayList<CharSequence> list = new ArrayList<String>();
    }
}

Kotlin 语言中 , 泛型参数是子类的泛型类对象 , 可以赋值给泛型参数是父类的变量 , 前提是泛型参数必须使用 out 关键字修饰 ;
- 使用 in 关键字 , 可以使父类泛型对象赋值给子类泛型对象 ;
- 使用 out 关键字 , 可以使子类泛型对象赋值给父类泛型对象 ;

下图中父类范围比子类范围大 ,

如果使用 in 关键字 , 则范围大的父类泛型对象赋值给范围小的子类泛型对象 , ( 反之就会报错 )
如果使用 out 关键字 , 则范围小的子类泛型对象赋值给范围大的父类泛型对象 ; ( 反之就会报错 )

使用了泛型 out 协变和泛型 in 逆变极大的提高了程序的扩展性 ;

在下面的代码中 , FoodFactory 是 Producer<Food> 子类 , 类型正好匹配 ;

    // FoodFactory 是 Producer<Food> 子类 , 类型正好匹配
    val producer: Producer<Food> = FoodFactory();

FastFoodFactory 是 Producer<FastFood> 子类 , Producer 的泛型参数 FastFood 是 Food 的子类 , 在 Kotlin 中 , 可以将 Producer<FastFood> 类型赋值给 Producer<Food> 类型 , 在 Java 中这种用法不行 ;

    // FastFoodFactory 是 Producer<FastFood> 子类
    // Producer 的泛型参数 FastFood 是 Food 的子类
    // 在 Kotlin 中 , 可以将 Producer<FastFood> 类型赋值给 Producer<Food> 类型
    // 在 Java 中这种用法不行
    val producer2: Producer<Food> = FastFoodFactory();

代码示例 :

import java.util.*

interface Producer<out T> {
    fun produce(): T
}
interface Consumer<in T> {
    fun consume(t: T)
}
interface ProducerOrConsumer<T> {
    fun produce(): T
    fun consume(t: T)
}

open class Food
open class FastFood : Food()
class Burger : FastFood()

class FoodFactory : Producer<Food> {
    override fun produce(): Food {
        println("生产食物")
        return Food()
    }
}
class FastFoodFactory : Producer<FastFood> {
    override fun produce(): FastFood {
        println("生产快餐")
        return FastFood()
    }
}
class BurgerFactory : Producer<Burger> {
    override fun produce(): Burger {
        println("生产汉堡")
        return Burger()
    }
}

class People : Consumer<Food> {
    override fun consume(t: Food) {
        println("人吃食物")
    }
}
class ModernPeople : Consumer<FastFood> {
    override fun consume(t: FastFood) {
        println("现代人吃快餐")
    }
}
class WestModernPeople : Consumer<Burger> {
    override fun consume(t: Burger) {
        println("西方现代人喜欢吃汉堡")
    }
}

fun main() {
    // I. 泛型 out 协变 , 使用 out 关键字 , 可以使 子类泛型对象 赋值给 父类泛型对象

    // FoodFactory 是 Producer<Food> 子类 , 类型正好匹配
    val producer: Producer<Food> = FoodFactory();
    producer.produce()

    // FastFoodFactory 是 Producer<FastFood> 子类
    // Producer 的泛型参数 FastFood 是 Food 的子类
    // 在 Kotlin 中 , 可以将 Producer<FastFood> 类型赋值给 Producer<Food> 类型
    // 在 Java 中这种用法不行
    val producer2: Producer<Food> = FastFoodFactory();
    producer2.produce()

    // II. 泛型 in 逆变 , 使用 in 关键字 , 可以使 父类泛型对象 赋值给 子类泛型对象
    // People 的类型是 Consumer<Food>
    // consumer 的类型是 Consumer<Burger>
    // 在 Consumer 中 , 使用了泛型参数 in 逆变
    // 泛型参数是父类 的泛型类对象 可以赋值给 泛型参数是子类 的泛型对象
    val consumer : Consumer<Burger> = People()
    consumer.consume(Burger())
}

执行结果 :

生产食物
生产快餐
人吃食物

十二、使用 reified 关键字检查泛型参数类型

泛型参数类型 T 在运行时会被类型擦除 , 因此在运行时是不知道泛型参数的具体类型的 ,

借助 reified 关键字可以检查运行时泛型参数的具体类型 ;

在 Java 中 , 运行时不知道泛型参数的具体类型 ; 在 Kotlin 中可以通过 reified 关键字检查泛型参数类型 ;

Java 中如果想要知道泛型参数具体类型 , 通过常规的方法无法实现 , 通过反射可以实现 ;

Java 泛型类对象.javaClass.name == "要判断的类的全类名"

在函数中使用 reified 关键字 , 需要在尖括号 <> 中泛型类型之前添加 reified 关键字 , 此外函数还要使用 inline 关键字进行修饰 ;

inline fun <reified T> 函数名(t: T): T {}

使用了 reified 关键字修饰泛型的 inline 函数中 , 可以使用 is 判定泛型参数的具体类型 ;

代码示例 :

open class Food
open class FastFood : Food()
class Burger : FastFood()

class Student<T: Food> () {
    inline fun eat(food: T) {
        if (food is Burger) {
            println("吃汉堡")
        } else if (food is FastFood) {
            println("吃快餐")
        } else if (food is Food) {
            println("吃普通食物")
        }
    }
}

fun main() {
    val student = Student<Food>()
    student.eat(Food())

    val student2 = Student<FastFood>()
    student2.eat(FastFood())

    val student3 = Student<Burger>()
    student3.eat(Burger())
}

执行结果 :