• 【Kotlin基础系列】第7章 类与对象(2)--- 继承


    1 继承

    Kotlin 中所有类都有一个共同的超类 Any,对于没有超类型声明的类它是默认超类,Any 有三个方法:equals()、 hashCode() 与 toString()。因此,为所有 Kotlin 类都定义了这些方法。默认情况下,Kotlin 类是最终(final)的——它们不能被继承。要使一个类可继承,请用 open 关键字标记它,如需声明一个显式的超类型,请在类头中把超类型放到冒号之后:

    1. open class Base(p: Int)
    2. class Derived(p: Int) : Base(p)

    如果派生类有一个主构造函数,其基类可以(并且必须)根据其参数在该主构造函数中初始化。

    如果派生类没有主构造函数,那么每个次构造函数必须使用super 关键字初始化其基类型,或委托给另一个做到这点的构造函数。 请注意,在这种情况下,不同的次构造函数可以调用基类型的不同的构造函数:

    1. class MyView : View {
    2. constructor(ctx: Context) : super(ctx)
    3. constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs)
    4. }

    1.1 覆盖方法

    Kotlin 对于可覆盖的成员以及覆盖后的成员需要显式修饰符:

    1. open class Shape {
    2. open fun draw() { /*……*/ }
    3. fun fill() { /*……*/ }
    4. }
    5. class Circle() : Shape() {
    6. override fun draw() { /*……*/ }
    7. }

    Circle.draw() 函数上必须加上 override 修饰符。如果没写,编译器会报错。 如果函数没有标注 open 如 Shape.fill(),那么子类中不允许定义相同签名的函数, 无论加不加 override。将 open 修饰符添加到 final 类(即没有 open 的类) 的成员上不起作用。

    标记为 override 的成员本身是开放的,因此可以在子类中覆盖。如果你想禁止再次覆盖, 使用 final 关键字

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

    1.2 覆盖属性 

    属性与方法的覆盖机制相同。在超类中声明然后在派生类中重新声明的属性必须以 override 开头,并且它们必须具有兼容的类型。 每个声明的属性可以由具有初始化器的属性或者具有 get 方法的属性覆盖:

    1. open class Shape {
    2. open val vertexCount: Int = 0
    3. }
    4. class Rectangle : Shape() {
    5. override val vertexCount = 4
    6. }

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

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

    1. interface Shape {
    2. val vertexCount: Int
    3. }
    4. class Rectangle(override val vertexCount: Int = 4) : Shape // 总是有 4 个顶点
    5. class Polygon : Shape {
    6. override var vertexCount: Int = 0 // 以后可以设置为任何数
    7. }

    1.3 派生类初始化顺序 

    在构造派生类的新实例的过程中,第一步完成其基类的初始化 (在之前只有对基类构造函数参数的求值),这意味着它发生在派生类的初始化逻辑运行之前。

    1. open class Base(val name: String) {
    2. init { println("Initializing a base class") }
    3. open val size: Int =
    4. name.length.also { println("Initializing size in the base class: $it") }
    5. }
    6. class Derived(
    7. name: String,
    8. val lastName: String,
    9. ) : Base(name.replaceFirstChar { it.uppercase() }.also { println("Argument for the base class: $it") }) {
    10. init { println("Initializing a derived class") }
    11. override val size: Int =
    12. (super.size + lastName.length).also { println("Initializing size in the derived class: $it") }
    13. }
    14. fun main() {
    15. println("Constructing the derived class(\"hello\", \"world\")")
    16. Derived("hello", "world")
    17. }

    这意味着,基类构造函数执行时,派生类中声明或覆盖的属性都还没有初始化。在基类初始化逻辑中(直接或者通过另一个覆盖的 open 成员的实现间接)使用任何一个这种属性,都可能导致不正确的行为或运行时故障。 设计一个基类时,应该避免在构造函数、属性初始化器或者 init 块中使用 open 成员。

    1.4 调用超类实现 

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

    1. open class Rectangle {
    2. open fun draw() { println("Drawing a rectangle") }
    3. val borderColor: String get() = "black"
    4. }
    5. class FilledRectangle : Rectangle() {
    6. override fun draw() {
    7. super.draw()
    8. println("Filling the rectangle")
    9. }
    10. val fillColor: String get() = super.borderColor
    11. }

    在一个内部类中访问外部类的超类,可以使用由外部类名限定的 super 关键字来实现:super@Outer

     

    1. open class Rectangle {
    2. open fun draw() { println("Drawing a rectangle") }
    3. val borderColor: String get() = "black"
    4. }
    5. class FilledRectangle: Rectangle() {
    6. override fun draw() {
    7. val filler = Filler()
    8. filler.drawAndFill()
    9. }
    10. inner class Filler {
    11. fun fill() { println("Filling") }
    12. fun drawAndFill() {
    13. super@FilledRectangle.draw() // 调用 Rectangle 的 draw() 实现
    14. fill()
    15. println("Drawn a filled rectangle with color ${super@FilledRectangle.borderColor}") // 使用 Rectangle 所实现的 borderColor 的 get()
    16. }
    17. }
    18. }
    19. fun main() {
    20. val fr = FilledRectangle()
    21. fr.draw()
    22. }

    1.5 覆盖规则 

    继承类或多实现接口时,相同的方法名字在子类中覆盖只需实现一个,调用相同名字方法使用super.xxx。

    1. open class Rectangle {
    2. open fun draw() { /* …… */ }
    3. }
    4. interface Polygon {
    5. fun draw() { /* …… */ } // 接口成员默认就是“open”的
    6. }
    7. class Square() : Rectangle(), Polygon {
    8. // 编译器要求覆盖 draw():
    9. override fun draw() {
    10. super.draw() // 调用 Rectangle.draw()
    11. super.draw() // 调用 Polygon.draw()
    12. }
    13. }

     可以同时继承 Rectangle 与 Polygon, 但是二者都有各自的 draw() 实现,所以必须在 Square 中覆盖 draw(), 并为其提供一个单独的实现以消除歧义。

  • 相关阅读:
    中央空调系统运行原理以及相关设备介绍
    接口自动化测试 —— Jmeter 6种定时器应用
    【量子学习笔记】纯态、混合态、直积态及纠缠态的概念区分及理解
    02 使用jenkins实现K8s持续集成
    2023年CSP-J真题详解+分析数据(题目篇)
    linux nuget packages path
    ::before 和 :after中双冒号和单冒号 有什么区别?解释一下这2个伪元素的作用
    Rust基础入门之(基本类型)
    如何做一个最便宜的小程序?
    高防CDN:保障网络安全的未来之路
  • 原文地址:https://blog.csdn.net/u010687761/article/details/127718755