Kotlin学习笔记（五）【继承】

继承说明

Kotlin 中所有类都继承自Any 类，它是所有类的超类，对于没有超类型声明的类是默认超类：

class Empty // 从Any隐式继承

Any 默认提供了三个函数：

equals()

hashCode()

toString()

注意：Any 不是 java.lang.Object。
Kotlin所有的类都默认是final，如果一个类要被继承，可以使用 open 关键字进行修饰。

open class Base(p: Int)

class Qfxl(p: Int) : Base(p)

构造函数

子类有主构造函数

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

fun main(args: Array<String>) {
    val stu = Student("qfxl","99",18)
    println("student's name is ${stu.name} score is ${stu.score} age is ${stu.age}")
}


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

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

子类没有主构造函数

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

class MyView : View {

    constructor(ctx: Context) : super(ctx)

    constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs)

    constructor(ctx: Context, attr: AttributeSet, defStyleAttr: Int) : super(ctx, attr, defStyleAttr)
}

如下所示：

fun main(args: Array<String>) {
    Student("qfxl",18)
}


open class Person(name: String) {
    constructor(name: String, age: Int) : this(name) {
        println("你调用了基类的次构造函数")
    }
}

class Student: Person {
    constructor(name: String, age: Int) : super(name, age) {
        println("Student name is $name age is $age")
    }
}

重写

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

fun main(args: Array<String>) {
    Student().speakLanguage()
}


open class Person {
  open fun speakLanguage() {
      println("I Speak CH")
  }
}

class Student: Person() {
    override fun speakLanguage() {
        println("I Speak Eng")
    }
}

输出：I Speak Eng

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

open class Person {
    open fun speakLanguage() {
        println("I Speak Language")
    }
}

interface Chinese {
    fun speakLanguage() { //接口所有方法默认是open
        println("I Speak Ch")
    }
}

class Student : Person(), Chinese {
    override fun speakLanguage() {
        super<Person>.speakLanguage()
        super<Chinese>.speakLanguage()
        println("I Speak 中文")
    }
}

Student继承了Chinese跟Person，由于speakLanguage只有一个实现，为了消除歧义，此时Student必须调用Chinese跟Person中的实现，并提供自己的实现。

属性重写

属性重写使用 override 关键字，属性必须具有兼容类型，每一个声明的属性都可以通过初始化程序或者getter方法被重写：

fun main(args: Array<String>) {
    val stu = Student()
    println(stu.name)
}

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

class Student : Person() {
    override val name: String
        get() = "Student"
}

你可以用一个var属性重写一个val属性，但是反过来不行。因为val属性本身定义了getter方法，重写为var属性会在衍生类中额外声明一个setter方法
你可以在主构造函数中使用 override 关键字作为属性声明的一部分:

interface Person {
    val name : String
}

class Chinesse(override val name: String): Person

class Student : Person{
    override val name: String
        get() = "Student"
}