kotlin:泛型约束

一，功能

在 尖括号 <> 中声明 泛型参数 时 , 可以指定 泛型类型 的 约束 , 如 泛型类型 必须是某个类型的子类

在 Kotlin 中，使用:代替 extends 对泛型的的类型上界进行约束。
传入的参数只能是指定的类型或其子类，如果是其他类型，则会报错。

二，例子

代码：

        //处理按钮点击事件
        binding.button1.setOnClickListener {
            open class Human(var age: Int)
            {
                fun info() {
                    println("今年${age}岁")
                }
            }
            class Boy(var name: String, _age: Int) : Human(_age)  //human子类

            class Man(var name: String, _age: Int) : Human(_age)  //human子类

            class Boy2(var name: String, _age: Int)
            //指定父类
            class Magic<T : Human>(_item: T) {
                var subOject: T = _item
                var available: Boolean = false
                fun info() {
                    subOject.info()
                }
            }
            val boy = Boy("danny", 15)
            val boy2 = Boy2("danny", 16)
            val man = Man("王富贵", 17)
            val human = Human(18)
            val magic1 = Magic(boy)
            magic1.info()
            //val magic2 = Magic(boy2)   //类型不符合，报错
            val magic3 = Magic(man)
            magic3.info()
            val magic4 = Magic(human)
            magic4.info()
        }

运行结果:

三，例子

代码：

        //处理按钮点击事件
        binding.button2.setOnClickListener {
            open class Weapon(var name: String){
                open fun fire(){
                    println("用weapon类${name}开火!")
                }
            }

            //泛型约束，父类必须是Weapon
            class Soldier<T : Weapon>(_item: T) {
                var item: T = _item

                fun fight(){
                    item.fire()
                }
            }

            // AK47，父类是Weapon
            class AK47: Weapon("AK47"){
                override fun fire(){
                    super.fire()
                    println("在用AK47开火")
                }
            }

            // knife，也是武器，但没有父类
            class knife {
                fun fire(){
                    println("在用小刀战斗")
                }
            }

            var soldier: Soldier<AK47> = Soldier(AK47())
            soldier.fight()

            var soldier2: Soldier<Weapon> = Soldier(Weapon("东风导弹"))
            soldier2.fight()

            // var soldier3: Soldier<knife> = Soldier(knife())  //类型不符合泛型约束，报错
            //soldier3.fight()
        }

运行结果:

四，例子

代码：

        //处理按钮点击事件:
        binding.button3.setOnClickListener {
            // 类型约束,实现了Printable接口
            class Document : Printable {
                override fun print() = println("打印文档")
            }

            class Image : Printable {
                override fun print() = println("打印图片")
            }

            class Video  {
                fun print() = println("打印视频截图")
            }

            // 泛型函数使用类型约束
            fun <T : Printable> printItem(item: T) {
                item.print()
            }

            // 使用
            val document = Document()
            val image = Image()
            val video = Video()

            printItem(document)  // 打印文档
            printItem(image)     // 打印图片
            //printItem(video)     // 报错，video没有实现Printable
        }

运行结果: