Kotlin 继承

我们知道Java中所有的类都继承于Object类，而在Kotlin中，Any类就相当于Java中的Object.
它是所有类的超类，对于没有超类型声明的类是默认超类。

class Demo // 从 Any 隐式继承

Any 默认提供了三个函数：

equals()

hashCode()

toString()

是不是跟Java中的Object一样?嘿!

如果一个类要被继承，可以使用 ++open++ 关键字进行修饰。

open class Base(p: Int)           // 定义基类

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

构造函数

继承中涉及构造函数分两种情况：

• 子类有主构造函数
• 子类没有主构造函数

子类有主构造函数

如果子类有主构造函数， 则基类必须在主构造函数中立即初始化。

open class Person (var name : String, var age : Int) {

    class Student(name : String, age : Int, var no : String, var score : Int) : Person(name, age) {

    }

    // 测试
    fun main(args: Array<String>) {
        val s =  Student("Jack", 18, "S12346", 89)
        println("学生名： ${s.name}")
        println("年龄： ${s.age}")
        println("学生号： ${s.no}")
        println("成绩： ${s.score}")
    }
}

输出结果：

学生名： Jack
年龄： 18
学生号： S12346
成绩： 89

如果不这样，就会出现

image

子类没有主构造函数

如果子类没有主构造函数，则必须在每一个次级构造函数中用 super 关键字初始化基类，或者在代理另一个构造函数。初始化基类时，可以调用基类的不同构造方法。
这跟Java其实是一样的。子类的构造方法都是会对父类初始化的

open class Person (var name : String, var age : Int) {

    class Student :Person {

        constructor(name : String, age : Int):super(name,age){
            
        }
    }
}

重写(override)

• 在基类中，使用fun声明函数时，此函数默认为final修饰，不能被子类重写
• 如果允许子类重写该函数，那么就要手动添加 open 修饰它
• 子类重写方法使用 override 关键词：

/**用户基类**/
open class Person{
    open fun study(){       // 允许子类重写
        println("我毕业了")
    }
}

/**子类继承 Person 类**/
class Student : Person() {

    override fun study(){    // 重写方法
        println("我上班了")
    }
}

fun main(args: Array<String>) {
    val s =  Student()
    s.study();

}

输出结果：

我上班了

如果有多个相同的方法（继承或者实现自其他类，如A、B类），则必须要重写该方法，使用super范型去选择性地调用父类的实现。

open class A {
    open fun f () { print("A") }
    fun a() { print("a") }
}

interface B {
    fun f() { print("B") } //接口的成员变量默认是 open 的
    fun b() { print("b") }
}

class C() : A() , B{
    override fun f() {
        super<A>.f()//调用 A.f()
        super<B>.f()//调用 B.f()
    }
}

fun main(args: Array<String>) {
    val c =  C()
    c.f();

}

C 继承自 a() 或 b(), C 不仅可以从 A 或则 B 中继承函数，而且 C 可以继承 A()、B() 中共有的函数。此时该函数在中只有一个实现，为了消除歧义，该函数必须调用A()和B()中该函数的实现，并提供自己的实现。
输出结果为:

AB

属性重写

• 属性重写使用 override 关键字
• 属性必须具有兼容类型
• 每一个声明的属性都可以通过初始化程序或者getter方法被重写
• var 属性可重写为val 属性,反之，则不行。
• 可以在主构造函数中使用 override 关键字作为属性声明的一部分

下面是示例：

open class Foo {
    open val x: Int get { …… }
}

class Bar1 : Foo() {
    override val x: Int = ……
}

还有：

interface Foo {
    val count: Int
}

class Bar1(override val count: Int) : Foo

class Bar2 : Foo {
    override var count: Int = 0
}