kotlin 泛型

一、泛型使用

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

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

1.1 泛型的优点
类型安全：通用允许仅保留单一类型的对象。泛型不允许存储其他对象。

不需要类型转换：不需要对对象进行类型转换。

编译时间检查：在编译时检查泛型代码，以便在运行时避免任何问题。

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

//1、创建泛型类
class TFood<T>(item:T) {
    init {
        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
}

1.3 泛型函数

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

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

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> 上界通配符
 

三、形变

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

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

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

3.1 不变

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

/**
 * 泛型接口  不变
 */
interface IUnchanged<T> {
    fun originally():T
    fun originally(item:T)

}
class BigStore:IUnchanged<String>{
    override fun originally(): String {
        return "实现泛型接口  不变---返回类型"
    }

    override fun originally(item: String) {
       println("------------不变---传参 ---=="+item)
    }
}

fun main() {
    println("---------------实现泛型接口------- 不变 默认---------------")
    var iUnchanged=BigStore()
    println(iUnchanged.originally())
    println(iUnchanged.originally("参数"))
}

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

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