Kotlin 2.1.0 入门教程（十五）继承、重写、派生类初始化顺序

继承

所有类都有一个共同的超类 Any，对于没有声明超类型的类来说，Any 是其默认的超类：

// 隐式继承自 Any。
class Example

Any 有三个方法：equals()、hashCode() 和 toString()。因此，所有类都定义了这些方法。

默认情况下，类是 final 的，即它们不能被继承。若要使一个类可被继承，需使用 open 关键字标记它：

// 该类可被继承。
open class Base

要声明一个显式的超类型，在类头中把类型放在冒号之后：

open class Base(p: Int)class Derived(p: Int) : Base(p)

如果派生类有主构造函数，基类必须根据其参数在该主构造函数中进行初始化。

如果派生类没有主构造函数，那么每个次构造函数都必须使用 super 关键字来初始化基类型，或者委托给另一个能完成此操作的构造函数。注意，在这种情况下，不同的次构造函数可以调用基类型的不同构造函数：

class MyView : View {constructor(ctx: Context) : super(ctx)constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs)
}

方法重写

对可重写的成员和重写操作使用显式修饰符：

open class Shape {open fun draw() { /*...*/ }fun fill() { /*...*/ }
}class Circle() : Shape() {override fun draw() { /*...*/ }
}

对于 Circle.draw() 方法，override 修饰符是必需的。如果缺少该修饰符，编译器将会报错。如果一个函数没有 open 修饰符，比如 Shape.fill()，那么在子类中声明具有相同签名的方法是不允许的，无论是否使用 override 修饰符。对于 final 类（即没有 open 修饰符的类）的成员，添加 open 修饰符是没有效果的。

标记为 override 的成员本身是 open 的，因此它可以在子类中被再次重写。如果你想禁止再次重写，可以使用 final 修饰符：

open class Rectangle() : Shape() {final override fun draw() { /*...*/ }
}

属性重写

属性的重写机制和方法的重写机制类似。在超类中声明的属性，若要在派生类中重新声明，必须在前面加上 override 关键字，并且它们的类型必须兼容。每个已声明的属性可以被一个带有初始值设定项的属性或一个带有 get 方法的属性重写：

open class Shape {open val vertexCount: Int = 0
}class Rectangle : Shape() {override val vertexCount = 4
}

你也可以用一个 var 属性重写一个 val 属性，但反之则不行。这是允许的，因为 val 属性本质上声明了一个 get 方法，而将其重写为 var 属性时，还会在派生类中额外声明一个 set 方法。

注意，你可以在主构造函数中把 override 关键字作为属性声明的一部分来使用：

interface Shape {val vertexCount: Int
}class Rectangle(override val vertexCount: Int = 4) : Shapeclass Polygon : Shape {override var vertexCount: Int = 0
}

派生类初始化顺序

在创建派生类的新实例的过程中，基类的初始化是第一步（仅在对基类构造函数的参数求值之后进行），这意味着基类的初始化会在派生类的初始化逻辑执行之前完成。

open class Base(val name: String,) {init { println("Initializing a base class") }open val size: Int = name.length.also {println("Initializing size in the base class: $it")}
}class Derived(name: String, val lastName: String,): Base(name.replaceFirstChar { it.uppercase() }.also { println("Argument for the base class: $it") })
{init { println("Initializing a derived class") }override val size: Int = (super.size + lastName.length).also {println("Initializing size in the derived class: $it")}
}fun main() {// Argument for the base class: Aaa// Initializing a base class// Initializing size in the base class: 3// Initializing a derived class// Initializing size in the derived class: 6Derived("aaa", "bbb")
}

这意味着当基类构造函数执行时，派生类中声明或重写的属性尚未初始化。在基类的初始化逻辑中使用这些属性（无论是直接使用，还是通过另一个被重写的开放成员的实现间接使用）可能会导致错误的行为或运行时故障。因此，在设计基类时，你应该避免在构造函数、属性初始化器或初始化块中使用开放成员。

调用超类实现

派生类中的代码可以使用 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 这种形式。下面通过具体的代码示例来详细解释：

open class SuperClass {open fun doSomething() {println("SuperClass is doing something.")}
}class Outer : SuperClass() {override fun doSomething() {println("Outer class is doing something.")}inner class Inner {fun callSuperClassMethod() {super@Outer.doSomething() }}
}fun main() {// SuperClass is doing something.Outer().Inner().callSuperClassMethod()
}

open class SuperClass {open fun doSomething() {println("SuperClass is doing something.")}
}class Outer : SuperClass() {override fun doSomething() {println("Outer class is doing something.")}inner class Inner {fun callSuperClassMethod() {doSomething() }}
}fun main() {// Outer class is doing something.Outer().Inner().callSuperClassMethod()
}

重写规则

实现继承受以下规则约束：如果一个类从其直接超类继承了同一成员的多个实现，那么它必须重写该成员并提供自己的实现（也许可以使用其中一个继承来的实现）。

为了指明从哪个超类型获取继承的实现，可以使用尖括号限定超类型名称的 super，例如 super<Base>：

open class Rectangle {open fun draw() {}
}interface Polygon {// 接口成员默认是 open 的。fun draw() {}
}class Square() : Rectangle(), Polygon {// 编译器要求重写 draw()。override fun draw() {super<Rectangle>.draw() // 调用 Rectangle 的 draw() 方法。super<Polygon>.draw() // 调用 Polygon 的 draw() 方法。}
}