Kotlin 类的继承

在 Kotlin 中所有类都有一个共同的超类 Any，这对于没有继承其他父类的超类型声明的类是默认超类：

class Example // 从 Any 隐式继承

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

默认情况下，Kotlin 类是最终（final）的：它们不能被继承。 要使一个类可继承，请用 open 关键字标记它。

open class Base // 该类开放继承

如需继承某个类，父类需加()，请在类头中把超类型放到冒号之后：

open class Base(p: Int)

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

子类构造器委托调用父类构造器

子类继承父类，子类构造器一定要直接或者间接委托调用调用父类构造器。

子类有声明主构造器时

首先，子类次构造器一定要直接或者间接委托调用子类的主构造器；

其次，子类主构造器一定要委托调用父类构造器，从而子类次构造器能够通过主构造器间接委托调用父类构造器。

open class Father {
    //父类有一个带有形参的构造器
    constructor(name: String?) {

    }
}


class Son(name: String?) : Father(name) {//子类继承于父类，同时子类主构造器委托调用父类构造器
    constructor() : this(null) {//子类次构造器委托调用子类主构造器，间接委托调用父类构造器

    }
    constructor(name: String, age: Int) : this() {//子类次构造器委托调用子类其他次构造器，间接委托调用子类主构造器，从而间接委托调用父类构造器

    }
}

子类未声明主构造器（但是声明了次构造器）时

子类无主构造器时，次构造器不需要委托调用子类主构造器或者其他次构造器，但需要直接或间接委托调用父类构造器。

open class Father {
    //父类有一个带有形参的构造器
    constructor(name: String?) {

    }
    //父类无参的次构造器
    constructor() {
        println("无参构造器")
    }
}



class Son : Father {
    constructor(name: String?, age: Int) : super(name) {//子类次构造器直接委托调用父类构造器

    }

    constructor() : this(null, 0) {//子类次构造器委托调用其他次构造器，间接委托调用父类构造器

    }

    constructor(age: Int) {//子类次构造器未显式委托调用子类其他次构造器，也没显示委托调用父类构造器时，会默认委托调用父类无参的构造器

    }
}

子类未显式声明任何构造器时

子类未显式声明任何构造器时，系统会为子类自动生成一个无参的主构造器，因此继承时需要委托调用父类构造器。

open class Father {
    //父类有一个带有形参的构造器
    constructor(name: String?) {}
}


class Son : Father(null)//声明时需为无参主构造器委托调用父类构造器

重写方法

我们之前提到过，Kotlin 力求清晰显式。因此，Kotlin 对于可覆盖的成员（我们称之为开放）以及覆盖后的成员需要显式修饰符：

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

class Circle() : Shape() {
    override fun draw() { /*……*/ }
}

Circle.draw() 函数上必须加上 override 修饰符。如果没写，编译器将会报错。

如果函数没有标注 open 如 Shape.fill()，那么子类中不允许定义相同签名的函数， 不论加不加 override。

将 open 修饰符添加到 final 类（即没有 open 的类）的成员上不起作用。

标记为 override 的成员本身是开放的，也就是说，它可以在子类中覆盖。如果你想禁止再次覆盖，使用 final 关键字：

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

重写方法遵循“两同、两小、一大”原则

• 两同：方法名相同、形参列表相同

open class Father {
    protected open fun method(a: String) {
        println("父类方法，传入参数：$a")
    }
}


class Son : Father() {
    protected override fun method(a: String) {
        println("子类类方法，传入参数：$a")
    }
}

• 两小：返回值类型比父类返回值类型小或相等、抛出异常类型比父类小或相等。

open class Father {
    protected open fun method(a: String) : Any? {
        println("父类方法，传入参数：$a")
        return null
    }
}


class Son : Father() {
    protected override fun method(a: String) : String?{
        println("子类类方法，传入参数：$a")
        return "返回值"
    }
}

• 一大：访问权限比父类大或相等

open class Father {
    protected open fun method(a: String) : Any? {
        println("父类方法，传入参数：$a")
        return null
    }
}


class Son : Father() {
    public override fun method(a: String) : String?{
        println("子类类方法，传入参数：$a")
        return "返回值"
    }
}

重写属性

属性覆盖与方法覆盖类似；在超类中声明然后在派生类中重新声明的属性必须以 override 开头，重写的子类属性的类型必须与父类属性类型兼容（变量类型）。

每个声明的属性可以由具有初始化器的属性或者具有 get 方法的属性覆盖。

open class Father {
    open var a : Float = 1.1f
}


class Son : Father() {
    override var a : Float = 2.2f
}

子类属性访问权限必须大于等于父类类型

open class Father {
    protected open var a : Float = 1.1f
}


class Son : Father() {
    public override var a : Float = 2.2f
}

只读属性（val）可被重写成读写属性（var），读写属性（var）不能被重写成只读属性（val）

因为一个 val 属性本质上声明了一个 get 方法， 而将其覆盖为 var 只是在子类中额外声明一个 set 方法。

open class Father {
    protected open val a : Float = 1.1f
}


class Son : Father() {
    public override var a : Float = 2.2f
}

强制重写

当子类同时继承多个超类（只能继承一个类，但可以实现多个接口）时，如果超类成员（属性/方法）名称一样时，子类需强制重写该成员。

子类想调用父类该成员（函数与属性），需通过super<父类名>.成员的方式调用。

interface FatherInterfs {
    var a: Float
    fun method() {
        println("执行父接口里面该方法 a的值为：$a")//2.2
    }
}


open class Father {
    protected open val a: Float = 1.1f
    open fun method() {
        println("执行父类该方法 $a")//2.2
    }
}


class Son : Father(), FatherInterfs {
    override var a: Float = 2.2f
    override fun method() {
        super<FatherInterfs>.method()
        super<Father>.method()
        println("执行子类该方法 $a")//2.2
        println("父接口a的值为 ${super<Father>.a}")//1.1
    }
}

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

class FilledRectangle: Rectangle() {
    override fun draw() { 
        val filler = Filler()
        filler.drawAndFill()
    }

    inner class Filler {
        fun fill() { println("Filling") }
        fun drawAndFill() {
            super@FilledRectangle.draw() // 调用 Rectangle 的 draw() 实现
            fill()
            println("Drawn a filled rectangle with color ${super@FilledRectangle.borderColor}") // 使用 Rectangle 所实现的 borderColor 的 get()
        }
    }
}

子类初始化顺序

抽象类

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

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

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

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