Kotlin-接口&抽象类

2022-10-01

接口&抽象类

1.接口定义

Kotlin规定所有的接口属性和函数实现都要使用override关键字,接口中定义的函数并不需要open关键字修饰,他们默认就是open的。

interface Movable{
    val maxSpeed: Int
        get() = (1..500).shuffled().last()

    var wheels: Int

    fun move(movable: Movable): String
}

class Car(_name: String,override var wheels: Int = 4) : Movable{
    override var maxSpeed: Int
        get() = super.maxSpeed
        set(value) {}

    override fun move(movable: Movable): String {
        TODO("Not yet implemented")
    }
}

可以在接口里提供默认属性的getter方法和函数实现

2.抽象类

要定义一个抽象类,需要在定义之前加上abstract关键字,除了具体的函数实现,抽象类也可以包含抽象函数（只有定义,没有函数实现）

abstract class Gun(val range: Int){
    abstract fun pullTrigger(): String

    protected fun doSomething(){
        println("doSomething")
    }
}

class AK47(val price: Int) : Gun(range = 500){
    override fun pullTrigger(): String {
        TODO("Not yet implemented")
    }
}

3.定义泛型类

泛型类的构造函数可以接受任何类型

MagicBox类指定的泛型参数由放在一对<>里的字母T表示,T是一个代表item类型的占位符。MagicBox类接受任何类型的item作为主构造函数值（item: T）,并将item值赋给同样是T类型的subject私有属性

class MagicBox<T>(item: T){
    private var subject: T = item
}

class Boy(val name: String,val age: Int)

class Dog(val weight: Int)

fun main(){
    val box_1: MagicBox<Boy> = MagicBox(Boy("Jack",20))
    val box_2: MagicBox<Dog> = MagicBox(Dog(20))
}

泛型参数可以用于函数

定义一个函数用于获取元素,当且仅当MagicBox可用时,才能获取元素。

class MagicBox<T>(item: T){
    private var subject: T = item
    var available = false

    fun fetch(): T?{
        //为true返回subject,为false返回空
        return subject.takeIf { available }
    }
}

class Boy(val name: String,val age: Int)

class Dog(val weight: Int)

fun main(){
    val box_1: MagicBox<Boy> = MagicBox(Boy("Jack",20))
    val box_2: MagicBox<Dog> = MagicBox(Dog(20))

    box_1.available = true
    box_1.fetch()?.run {
        println("you find $name")
    }
}

泛型函数或泛型类也可以有多个泛型函数

class MagicBox<T>(item: T){
    private var subject: T = item
    var available = false

    fun fetch(): T?{
        //为true返回subject,为false返回空
        return subject.takeIf { available }
    }

    //return -> R
    fun <R> fetch(subjectModFunction: (T) -> R): R?{
        return subjectModFunction(subject)
    }
}

class Boy(val name: String,val age: Int)

class Man(val name: String,val age: Int)

class Dog(val weight: Int)

fun main(){
    val box_1: MagicBox<Boy> = MagicBox(Boy("Jack",20))
    val box_2: MagicBox<Dog> = MagicBox(Dog(20))

    box_1.available = true
    box_1.fetch()?.run {
        println("you find $name")
    }

    box_1.fetch{
        Man(it.name,it.age.plus(10))
    }
}

3.1泛型类型约束

如果要确保MagicBox里面只能装指定类型的物品,如Boy类型

class MagicBox<T: Boy>(item: T){
    private var subject: T = item
    var available = false

    fun fetch(): T?{
        //为true返回subject,为false返回空
        return subject.takeIf { available }
    }

    //return -> R
    fun <R> fetch(subjectModFunction: (T) -> R): R?{
        return subjectModFunction(subject)
    }
}