11. Kotlin继承

Kotlin中所有的类都继承自 Any 类。Any 是所有类的超类。
Any提供了三个函数
equals()、hashCode()、toString()
一个类如果希望被别的类继承，可以使用 open 关键字进行修饰。

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

有主构造函数的子类

子类有主构造函数的，基类在主构造函数中初始化。

package main

fun main(args: Array<String>) {
    val s = Student("金龙翼", 27, "A737509111722", 100)
    println("学生姓名：${s.name}")
    println("年龄：${s.age}")
    println("学号：${s.no}")
    println("成绩：${s.score}")
}

open class Person(var name: String, var age: Int){
    //基类
}

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

}

运行结果

学生姓名：金龙翼
年龄：27
学号：A737509111722
成绩：100

子类没有主构造函数时，必须在每一个二级构造函数中用 super 关键字初始化基类，或者在代理另一个构造函数。初始化基类时，可以调用基类的不同构造方法。
子类和基类

open class Person2(name: String){
    constructor(name: String, age: Int): this(name){
        //基类次级构造
        println("-----------基类次级构造函数-------------")
    }
}
class Student2:Person2{
    constructor(name: String, age: Int, no: String, store: Int): super(name, age){
        println("----------继承类次级构造函数------------")
        println("学生姓名：${name}")
        println("年龄：${age}")
        println("学号：${no}")
        println("成绩：${store}")
    }
}

主函数中直接实例化

var ss = Student2("天龙", 25, "B90161015", 120)

看运行结果

-----------基类次级构造函数-------------
----------继承类次级构造函数------------
学生姓名：天龙
年龄：25
学号：B90161015
成绩：120

重写

当我们写一个 fun 函数时，此函数默认为 final 修饰。当我们需要允许子类重写该函数的，需要手动添加 open 修饰它。子类重写方法使用 override 关键字。

package main

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

open class Person{
    open fun study(){
        println("我毕业了")
    }
}

open class Student: Person(){
    override fun study() {
        println("我在读大学")
    }
}

运行这段代码，就会发现，输出的是

我在读大学

呵呵，当然我没在读大学了。只是，这里用重写 override fun study() 替换了基类内的 open fun study() 执行。
这只是继承了一个类，如果子类继承了类同时还有接口，并且这些类和接口还有相同的函数方法，子类必须要重写该函数方法，使用 super 泛型选择性地调用父类的实现。

package main

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

    val c = C()
    c.f()

    val d = D()
    d.f()
}

open class Person{
    open fun study(){
        println("我毕业了")
    }
}

open class Student: Person(){
    override fun study() {
        println("我在读大学")
    }
}

open class A{
    open fun f(){
        println("A")
    }
    fun a(){
        println("a")
    }
}
interface B{
    fun f(){
        println("B")
    }
    fun b(){
        println("b")
    }
}
open class DD{
    open fun f(){
        println("DD")
    }
    fun dd(){
        println("dd")
    }
}
class C(): A(), B{
    override fun f() {
        super<A>.f()
        super<B>.f()
    }
}
class D(): DD(), B{
    override fun f() {
        super<B>.f()
        super<DD>.f()
    }
}

运行结果

A
B
B
DD

属性重写

属性重写也需要用到 override ，属性必须具有兼容类型，每个声明的属性都可以通过初始化程序或者 getter 方法被重写。

package main

fun main(args: Array<String>) {
    var s = Student()
    println(s.name)

    var b = Bar2()
    println(b.x)
}

interface Foo{
    val x:Int
}

class Bar1(override val x: Int):Foo

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


open class Person{
    open val name: String = "Joel"
}

class Student:Person(){
    override var name = "Cofox"
}

运行结果

Cofox
0