美文网首页
Kotlin语言(六):泛型

Kotlin语言(六):泛型

作者: SupKing_a520 | 来源:发表于2022-01-14 17:32 被阅读0次

    1、泛型类

    /**
     * 1、泛型的定义
     * (1)类名后面接 <T> 定义泛型,其中 T 可以任意指定
     * (2)主构函数里面的 T 为泛型使用,代表其参数为 T 类型
     */
    open class Box<T>(var thing: T)
    
    
    /**
     * 2、泛型类的继承
     * (1)已知具体类型则使用具体类型
     * (2)未知具体类型则继续以泛型类定义
     */
    abstract class Fruit
    
    class Apple : Fruit()
    class FruitBox(thing: Fruit) : Box<Fruit>(thing)
    
    class SonBox<T>(thing: T) : Box<T>(thing)
    
    
    fun main() {
        val box = Box<String>("空箱子")
    
        val apple = Apple()
        val fruitBox = FruitBox(apple)
    
        val sonBox = SonBox<Fruit>(apple)
    }
    

    2、泛型函数

    /**
     * 1、泛型函数
     * (1)fun 关键字后面、函数名前面的 <T> 为泛型的定义
     * (2)参数类型 T 为泛型的使用
     */
    fun <T> parseType(thing: T) {
        when(thing){
            is Int -> println("Int类型")
            is String -> println("String类型")
            else -> println("未知类型")
        }
    }
    
    fun main() {
        parseType(10)       //Int 类型
        parseType("Kotlin") //String 类型
        parseType(1L)       //未知类型
    }
    

    3、泛型上限

    /**
     * 泛型上限:<T : Fruit> 泛型只能是 Fruit 或者 Fruit 的子类
     */
    open class Fruit
    class Apple : Fruit()
    
    open class Thing
    class Orange : Thing()
    
    class FruitBox<T : Fruit>(var fruit: T)
    
    
    fun main() {
        val fruit = Fruit()
        val fruitBox0 = FruitBox(fruit)
        val apple = Apple()
        val fruitBox1 = FruitBox(apple)
    
        val orange = Orange()
        //val fruitBox2 = FruitBox(orange) //编译失败,orange 不是 Fruit 的子类
    }
    

    4、泛型擦除

    /**
     * 1、泛型擦除
     * (1)和 java 一样,kotlin 也是通过类型擦除来支持泛型的
     * (2)kotlin 的泛型在运行时被擦除了,获取不到泛型的具体类型
     * (3)泛型类型只存在于编译阶段
     *
     * 2、解决泛型擦除(声明成内联函数)
     * (1)在泛型的定义前加上 reified
     * (2)在函数最前面加上 inline
     */
    class Box<T>(var thing: T)
    
    inline fun <reified T> parseType(thing: T){
        println(T::class.java)
    }
    
    fun main() {
        val box1 = Box<Int>(10)
        val box2 = Box<String>("Kotlin")
    
        //泛型被擦除了,所以这里获取到的都是 Box 类型,而没有泛型的具体类型
        println(box1.javaClass) //class com.wf.kotlin.study.Box
        println(box2.javaClass) //class com.wf.kotlin.study.Box
    
        //内联函数使得类型不会被擦除
        parseType(10) //class java.lang.Integer
        parseType("") //class java.lang.String
    }
    

    5、泛型投射

    open class Thing
    
    open class Fruit : Thing()
    
    class Apple : Fruit()
    
    /**
     * 泛型投射
     * (1)<out Fruit>:接受当前类或它的子类,相当于 java 的  <? extends Fruit>
     * (2)<in Fruit>:接收当前类或它的父类,相当于 java 的  <? super Fruit>
     */
    fun printFruitList1(list: ArrayList<out Fruit>) {
        println(list.size)
    }
    
    fun printFruitList2(list: ArrayList<in Fruit>) {
        println(list.size)
    }
    
    
    fun main() {
        val things = ArrayList<Thing>()
        val fruits = ArrayList<Fruit>()
        val apples = ArrayList<Apple>()
    
        //printFruitList1(things) //编译失败,只接收 Fruit 及其子类
        printFruitList1(fruits)
        printFruitList1(apples)
    
        printFruitList2(things)
        printFruitList2(fruits)
        //printFruitList2(apples) //编译失败,只接收 Fruit 及其父类
    }
    

    6、星号投射

    /**
     * 星号投射
     * <*>:代表可以传任何类型,相当于 java 的  <?>
     */
    fun boxingThings(list: ArrayList<*>){
        println(list.size)
    }
    
    fun main() {
        val strings = ArrayList<String>()
        boxingThings(strings)
    
        val ints = ArrayList<Int>()
        boxingThings(ints)
    }
    

    相关文章

      网友评论

          本文标题:Kotlin语言(六):泛型

          本文链接:https://www.haomeiwen.com/subject/taaacrtx.html