一、泛型使用

泛型，即 "参数化类型"，将类型参数化，可以用在类，接口，函数上。

与 Java 一样，Kotlin 也提供泛型，为类型安全提供保证，消除类型强转的烦恼。

1.1 泛型的优点

• 类型安全：通用允许仅保留单一类型的对象。泛型不允许存储其他对象。
• 不需要类型转换：不需要对对象进行类型转换。
• 编译时间检查：在编译时检查泛型代码，以便在运行时避免任何问题。

1.2 泛型类

TFood类指定的泛型参数由放在一对<>里的字母T表示，T是个代表item类型的占位符。TFood类接受任何类型的item作为主构造函数值（item: T)。

//1、创建泛型类
class TFood<T>(item:T){
    init {
//        //使用is来检查item的类型。
//        if(item is TApple){
//            //使用 as?先进行安全类型转换，然后使用?.避免空指针
//            println((item as? TApple)?.price)
//        }else{
//            println(item)
//        }
        //以上内容，可以用下面一行搞定。
        println(if(item is TApple)((item as? TApple)?.price)else item)
    }
}
//2、创建传入的类
class TApple(var price :Int)
//3、使用
fun main() {
    //传入Int类型
    TFood(30)//30
    //传入String类型
    TFood("水果")//水果
    //传入实体对象
    TFood(TApple(13))//13
}

此处如果不适用泛型，那么根据传入不同的引用类型可能需要创建多个类来接收。

泛型参数通常用字母T(代表英文type）表示，当然也可以用其他字母表示。不过，其他支持泛型的语言都在用这个约定俗成的T，所以建议你继续用它，这样写出的代码别人更容易理解。

1.3 泛型函数

泛型参数也可以用于函数。

定义一个函数用于获取元素，当且仅当泛型类可用时，才能获取元素。

class TFood<T>(item:T){
    var tem:T = item
    //添加泛型函数
    fun getItem():T?{
        return tem
    }
    
    //多泛型参数,<R>返回泛型类型
    fun <R> getItem(itemFun: (T) -> R): R {
        return itemFun(tem)
    }
}
    //传入String类型
    var s = TFood("水果")//水果
    //传入实体对象
    var apple = TFood(TApple(13))//13
    //使用泛型函数
    s.getItem().run {
        println(this)//水果
    }
    apple.getItem().run {
        println(this)//实例对象：TApple@3f3afe78
        println(this?.price)//13
    }
    
    //传入Type类型，返回Int类型
    var intType = apple.getItem {
        //it:TApple
        it.price
    }

1.4 泛型接口

//定义泛型接口
interface IFoodEffect<T>{
    fun effect(item:T)
}
//实现接口
class Banana:IFoodEffect<String>{
    override fun effect(item: String) {
        println(item)//item
    }

}
    //使用
    Banana().effect("常食香蕉有益于大脑，预防神经疲劳，还有润肺止咳、防止便秘")
    

二、泛型类型约束

指定参数类型：我想让这个泛型类只能传入某种类型。

open class Vip(price:Int)

class TApple(var price: Int): Vip(price)
class TFood<T:Vip>(item: T) {
    ...
}

T:Vip，这样写就表示这里只能传入Vip和其子类。这个就类似Java的 <? extends T> 上界通配符

因为Int和String类型未继承Vip类，所以报错。

三、形变

• out(协变)：它只能出现在函数的输出位置，只能作为返回类型，即生产者。

• in(逆变)：它只能出现在函数的输入位置，作为参数，只能作为消费类型，即消费者。

• 默认(不变)：如果泛型类既将泛型类型作为函数参数，又将泛型类型作为函数的输出，那么既不用out也不用in。

3.1 不变

泛型类型即作为输出又作为参数。

//不变
interface IUnchanged<T> {
    //可返回T
    fun originally(): T
    //可作为参数传入T
    fun originally(t:T)
}

class BigStore:IUnchanged<Fruit>{
    override fun originally(): Fruit {
        return Fruit()
    }

    override fun originally(t: Fruit) {
    }
}
class SmallStore:IUnchanged<AppleHn>{
    override fun originally(): AppleHn {
        return AppleHn()
    }

    override fun originally(t: AppleHn) {
    }
}
fun main() {
    println("-------------")
    var bs:IUnchanged<Fruit> = BigStore()
    println(bs)
    var ss:IUnchanged<AppleHn> = SmallStore()
    println(ss)
}

3.2 out-协变

它只能出现在函数的输出位置，只能作为返回类型，即生产者。

作用：可以将子类泛型对象可以赋值给父类泛型对象。

//out
interface IReturn<out T>{
    fun effect():T
}

open class Fruit()
class AppleHn():Fruit()

//生产者
class FruitMarket:IReturn<Fruit>{
    override fun effect(): Fruit {
        println("FruitMarket effect")
        return Fruit()
    }
}
class AppleHnMarket:IReturn<AppleHn>{
    override fun effect(): AppleHn {
        println("AppleHnMarket effect")
        return AppleHn()
    }
}

fun main() {
    //out:可以将子类泛型对象(AppleHn)可以赋值给父类泛型对象(Fruit)
    var fm:IProduction<Fruit> = FruitMarket()
    println(fm.effect())
    //am的引用类型是Fruit对象
    //但是AppleHnMarket返回的是AppleHn对象。
    //这里将AppleHn对象赋值给Fruit对象并返回。
    var am:IProduction<Fruit> = AppleHnMarket()
    println(am.effect())
}

3.3 in-逆变

它只能出现在函数的输入位置，只能作为参数，即消费者。

作用：可以将父类泛型对象可以赋值给子类泛型对象。

//in
interface IConsumer<in T>{
    fun spend(t:T)
}

class Animal:IConsumer<Fruit>{
    override fun spend(t: Fruit) {
        println("Animal spend Fruit")
    }
}

class People:IConsumer<AppleHn>{
    override fun spend(t: AppleHn) {
        println("People spend AppleHn")
    }
}
fun main() {
    //in:可以将父类泛型对象(Fruit)可以赋值给子类泛型对象(AppleHn)
    var fca: IConsumer<AppleHn> = Animal()
    fca.spend(AppleHn())
    println(fca)
    var fcp: IConsumer<AppleHn> = People()
    fcp.spend(AppleHn())
    println(fcp)
}

四、inline + reified

不管是Java还是Kotlin泛型在运行时会被擦除，但Kotlin可以使用内联函数避免这种限制，内联函数的类型形参能够被实化。

inline 函数除了可以提高性能，内联代码之外，另一种场景就是类型参数可以被实化。

如果把函数声明成 inline 并且用 reified 标记类型参数，就可以实化该类型参数。

class BookS<T : AndroidS> {
    //    fun <T> readBookT(anonymous: () -> T): T {
//        var list = listOf(
//            KotlinS("Kotlin 初学者", 12),
//            JavaS("Java 帅次", 28)
//        )
//        var data = list.shuffled().first()
//        return if (data is T) {
//            data
//        } else {
//            anonymous()
//        }
//    }
    //T的类型由anonymous()返回类型推断决定
    inline fun <reified T> readBook(anonymous: () -> T): T {
        var list = listOf(
            KotlinS("Kotlin 初学者", 12),
            JavaS("Java 帅次", 28)
        )
        var data = list.shuffled().first()
        println(data)
        //如果data是T则返回data,否则执行anonymous()
        return if (data is T) {
            data
        } else {
            anonymous()
        }
    }
}

open class AndroidS(name: String)
class KotlinS(var name: String, var price: Int) : AndroidS(name){
    override fun toString(): String {
        return "KotlinS(name='$name', price=$price)"
    }
}
class JavaS(var name: String, var price: Int) : AndroidS(name){
    override fun toString(): String {
        return "JavaS(name='$name', price=$price)"
    }
}

fun main() {
    var bookS:BookS<AndroidS> = BookS()
    //由anonymous()推断决定T的类型，这里的T是KotlinS
    var data = bookS.readBook {
        KotlinS("Anonymous-K",23)
    }
    println(data)
}

泛型T是KotlinS，list随机产生结果有两种分别是KotlinS和JavaS

产生KotlinS运行结果： 直接返回产生的KotlinS

"E:\Android\Android StudioO\jre\bin\java.exe"
KotlinS(name='Kotlin 初学者', price=12)
KotlinS(name='Kotlin 初学者', price=12)

Process finished with exit code 0

产生JavaS运行结果： 调用anonymous()函数返回KotlinS

"E:\Android\Android StudioO\jre\bin\java.exe"
JavaS(name='Java 帅次', price=28)
KotlinS(name='Anonymous-K', price=23)

Process finished with exit code 0

五、vararg

泛型类一次只能放一个，如果需要放入多个实例呢?

class BookMany<T : AndroidMany>(vararg item: T) {
    var data: Array<out T> = item
}

open class AndroidMany(name: String)
class KotlinMany(var name: String, var price: Int) : AndroidMany(name) {
    override fun toString(): String {
        return "KotlinS(name='$name', price=$price)"
    }
}

class JavaMany(var name: String, var price: Int) : AndroidMany(name) {
    override fun toString(): String {
        return "JavaS(name='$name', price=$price)"
    }
}

fun main() {
    var book = BookMany(
        KotlinMany("初学者", 18),
        KotlinMany("进阶者", 28),
        KotlinMany("终结者", 38),
        JavaMany("全面者", 35),
    )
    println(book)//com.scc.kotlin.primary.classkotlin.BookMany@3d24753a
}

添加完多个对象，如果直接打印book，那么获取到的是个BookMany对象，那么怎么获取book里面的的对象？

重载运算符函数get函数,通过[]操作符取值。

class BookMany<T : AndroidMany>(vararg item: T) {
    var data: Array<out T> = item
    operator fun get(index:Int) = data[index]
}

fun main() {
    var book = BookMany(
        KotlinMany("初学者", 18),
        KotlinMany("进阶者", 28),
        KotlinMany("终结者", 38),
        JavaMany("全面者", 35),
    )
    println(book)//com.scc.kotlin.primary.classkotlin.BookMany@3d24753a
    println(book[0])//KotlinS(name='初学者', price=18)
    println(book[2])//KotlinS(name='终结者', price=38)
}