kt基础-协变和逆变

//总结，什么时候使用in/out
//SuperType 可以分配SubType，使用 in
//SubType 可以分配给 SuperType，使用 out

package com.test.ktbase.djttest

//out（协变）
interface Production<out T>{
    fun produce(): T
}

//in（逆变）
interface Consumer<in T>{
    fun consume(item: T)
}

open class Food
open class FastFood: Food() //快餐
class Checken: FastFood()

/*协变示例*/
class FoodStore: Production<Food> {
    override fun produce(): Food {
        println("produce 食物")
        return Food() //返回Food类
    }
}

class FastFoodStore: Production<FastFood>{
    override fun produce(): FastFood {
        println("produce 快餐")
        return FastFood() //返回FastFood类
    }
}

class InOutChecken: Production<Checken>{
    override fun produce(): Checken {
        println("produce 炸鸡")
        return Checken() //返回Checken类
    }
}
/*协变示例*/


/*逆变示例*/
class EveryBody: Consumer<Food> {
    override fun consume(item: Food) {
        println("everybody 吃食物")
    }
}

class ChinesePeople: Consumer<FastFood> {
    override fun consume(item: FastFood) {
        println("ChinesePeople 吃快餐")
    }
}

class Cantonese : Consumer<Checken> {
    override fun consume(item: Checken) {
        println("广东人 吃炸鸡")
    }
}
/*逆变示例*/


fun main(){
    //out（协变）
    //我们可以将这些不同的子类型（食物，快餐，炸鸡），都分配给食品生产持有者
    //？使用out关键字，可以把子类型的类分配给超类型的类
    val production1: Production<Food> = FoodStore()
    val production2: Production<Food> = FastFoodStore()
    val production3: Production<Food> = InOutChecken()
    production1.produce()
    production2.produce()
    production3.produce()

    //in(逆变)
    //我们让消费者持有炸鸡，然后将上面的类(即超类，如EveryBody，ChinesePeople，Cantonese，这三个类对应不同的food)全部分配给它(指子类)
    //使用in关键字，我们可以将超类型的类分配给子类型的类
    val consumer1: Consumer<Checken> = EveryBody()
    val consumer2: Consumer<Checken> = ChinesePeople()
    val consumer3: Consumer<Checken> = Cantonese()
    consumer1.consume(Checken())
    consumer2.consume(Checken())
    consumer3.consume(Checken())


}

打印：

produce 食物
produce 快餐
produce 炸鸡
everybody 吃食物
ChinesePeople 吃快餐
广东人 吃炸鸡