Kotlin的重写

Kotlin的重写

重写方法

在kotlin中如果一个方法可以重写覆盖,就需要用open字段修饰这个方法,同时重写的方法必须使用override修饰,如果没有使用open修饰,则子类不允许命名相同名字的函数,

class NetworkConfig : Base() {
    
    override fun draw() {
        super.draw()
    }

}

open class Base {

    open fun draw() { /*……*/ }
    fun fill() { /*……*/ }
}

属性的覆盖

和重写方法一样,需要用open字段修饰这个属性,同时重写的属性必须使用override修饰,如果没有使用open修饰,则子类不允许命名相同名字的属性

open class Base {
   open val i: Int = 0
}

class NetworkConfig : Base() {
    override val i = 0
}

但是不同的是
你可以用一个 var 属性覆盖一个 val 属性，但反之则不行,因为一个 val 属性本质上声明了一个 get 方法， 而将其覆盖为 var 只是在子类中额外声明一个 set 方法。

属性的覆盖还可以在构造函数里使用

open class Base {
   open var i: Int = 0

}

class NetworkConfig(override var i: Int = 0) : Base() {

}

#关于基类和子类的执行顺序

open class Base(val name: String) {

    init { println("Initializing Base") }

    open val size: Int = 
        name.length.also { println("Initializing size in Base: $it") }
}

class Derived(name: String, val lastName: String) :
 Base(name.capitalize()
                    .also { println("Argument for Base: $it") }) {

    init { println("Initializing Derived") }

    override val size: Int =
        (super.size + lastName.length).also { println("Initializing size in Derived: $it") }
}
//==================执行结果=============================
Argument for Base: Hello
Initializing Base
Initializing size in Base: 5
Initializing Derived
Initializing size in Derived: 10

从这里可以看到,基类构造函数执行时，派生类中声明或覆盖的属性都还没有初始化。如果在基类初始化逻辑中（直接或通过另一个覆盖的 open 成员的实现间接）使用了任何一个这种属性，那么都可能导致不正确的行为或运行时故障。设计一个基类时，应该避免在构造函数、属性初始化器以及 init 块中使用 open 成员。

调用超类实现

派生类中的代码可以使用 super 关键字调用其超类的函数与属性访问器的实现：

open class Rectangle {
    open fun draw() { println("Drawing a rectangle") }
    val borderColor: String get() = "black"
}
​
class FilledRectangle : Rectangle() {
    override fun draw() {
        super.draw()
        println("Filling the rectangle")
    }
​
    val fillColor: String get() = super.borderColor
}

在一个内部类中访问外部类的超类，可以通过由外部类名限定的super关键字来实现：super@Outer：

class FilledRectangle: Rectangle() {
    fun draw() { /* …… */ }
    val borderColor: String get() = "black"
    
    inner class Filler {
        fun fill() { /* …… */ }
        fun drawAndFill() {
            super@FilledRectangle.draw() // 调用 Rectangle 的 draw() 实现
            fill()
            println("Drawn a filled rectangle with color ${super@FilledRectangle.borderColor}") // 使用 Rectangle 所实现的 borderColor 的 get()
        }
    }
}
class FilledRectangle: Rectangle() {
    fun draw() { /* …… */ }
    val borderColor: String get() = "black"
    //inner 代表内部类
    inner class Filler {
        fun fill() { /* …… */ }
        fun drawAndFill() {
            super@FilledRectangle.draw() // 调用 Rectangle 的 draw() 实现
            fill()
            println("Drawn a filled rectangle with color ${super@FilledRectangle.borderColor}") // 使用 Rectangle 所实现的 borderColor 的 get()
        }
    }
}

覆盖规则

在Kotlin中，实现继承由下述规则规定：如果一个类从它的直接超类继承相同成员的多个实现， 它必须覆盖这个成员并提供其自己的实现（也许用继承来的其中之一）。 为了表示采用从哪个超类型继承的实现，我们使用由尖括号中超类型名限定的super，如super<Base>：

open class Rectangle {
    open fun draw() { /* …… */ }
}

interface Polygon {
    fun draw() { /* …… */ } // 接口成员默认就是“open”的
}

class Square() : Rectangle(), Polygon {
    // 编译器要求覆盖 draw()：
    override fun draw() {
        super<Rectangle>.draw() // 调用 Rectangle.draw()
        super<Polygon>.draw() // 调用 Polygon.draw()
    }
}

抽象类

类以及其中的某些成员可以声明为abstract。 抽象成员在本类中可以不用实现。 需要注意的是，我们并不需要用open标注一个抽象类或者函数——因为这不言而喻。

我们可以用一个抽象成员覆盖一个非抽象的开放成员

open class Polygon {
    open fun draw() {}
}

abstract class Rectangle : Polygon() {
    abstract override fun draw()
}