【Kotlin】泛型 ③ ( 泛型 out 协变 | 泛型 in 逆变 | 泛型 invariant 不变 | 泛型逆变协变代码示例 | 使用 reified 关键字检查泛型参数类型 )

韩曙亮

发布于 2023-03-30 18:54:59

2.4K00

代码可运行

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

运行总次数：0

代码可运行

文章目录

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

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

一、泛型 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())
}

执行结果 :