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() {
[email protected]() // 调用 Rectangle 的 draw() 实现
fill()
println("Drawn a filled rectangle with color ${[email protected]}") // 使用 Rectangle 所实现的 borderColor 的 get()
}
}
}
class FilledRectangle: Rectangle() {
fun draw() { /* …… */ }
val borderColor: String get() = "black"
//inner 代表内部类
inner class Filler {
fun fill() { /* …… */ }
fun drawAndFill() {
[email protected]() // 调用 Rectangle 的 draw() 实现
fill()
println("Drawn a filled rectangle with color ${[email protected]}") // 使用 Rectangle 所实现的 borderColor 的 get()
}
}
}
覆盖规则
在Kotlin中，实现继承由下述规则规定：如果一个类从它的直接超类继承相同成员的多个实现， 它必须覆盖这个成员并提供其自己的实现（也许用继承来的其中之一）。 为了表示采用从哪个超类型继承的实现，我们使用由尖括号中超类型名限定的super，如super：
open class Rectangle {
open fun draw() { /* …… */ }
}
interface Polygon {
fun draw() { /* …… */ } // 接口成员默认就是“open”的
}
class Square() : Rectangle(), Polygon {
// 编译器要求覆盖 draw()：
override fun draw() {
super.draw() // 调用 Rectangle.draw()
super.draw() // 调用 Polygon.draw()
}
}
抽象类
类以及其中的某些成员可以声明为abstract。 抽象成员在本类中可以不用实现。 需要注意的是，我们并不需要用open标注一个抽象类或者函数——因为这不言而喻。
我们可以用一个抽象成员覆盖一个非抽象的开放成员
open class Polygon {
open fun draw() {}
}
abstract class Rectangle : Polygon() {
abstract override fun draw()
}