Kotlin语言（六）：泛型

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