Kotlin速记-继承

继承

Kotlin 中所有类都继承该 Any 类，它是所有类的超类(相当于 Java 中的 java.lang.Object ，但实质是不一样的)，对于没有超类型声明的类是默认超类， Any 默认提供三个函数：equals()；hashCode()；toString()。 如果一个类要被继承，可以使用 open 关键字进行修饰。

// 定义基类
open class Base(b: Int)           
​
// 让 Test 继承 Base
class Test(t: Int) : Base(b)

构造函数

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

// 基类
open class Person(var name : String, var age : Int){
​
}
​
class Student(name : String, age : Int, var sex : String, var score : Int) : Person(name, age) {
​
}
​
val s = Student("Simplation", 18, "男", 80)
​
s.name
res31: kotlin.String = Simplation
​
s.age
res32: kotlin.Int = 18
​
s.sex
res33: kotlin.String = "男"
​
s.score
res34: kotlin.Int = 80

重写

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

open class Person {
    // 允许子类重写：open 修饰
    open fun eat() {
        println("吃饭")
    }
}
​
// 继承 Person
class Children : Person() {
    // 重写 Person 中的 eat 方法
    override fun eat() {
        super.eat()
        
        println("我在吃东西.")
    }
}
​
val c = Children()
c.eat()
吃饭我在吃东西.

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

// C 继承自 a() 或 b(), C 不仅可以从 A 或则 B 中继承函数，而且 C 可以继承 A()、B() 中共有的函数。
// 此时该函数在中只有一个实现，为了消除歧义，该函数必须调用A()和B()中该函数的实现，并提供自己的实现。
open class A {
    open fun f () {
        print("A") 
    }
    
    fun a() {
        print("a") 
    }
}
​
interface B {
    // 接口的成员变量默认是 open 的
    fun f() { print("B") } 
    fun b() { print("b") }
}
​
class C() : A() , B{
    override fun f() {
        // 调用 A.f()
        super<A>.f()
        
        // 调用 B.f()
        super<B>.f()
    }
}
​
// 调用
val c =  C()
c.f();
AB

属性重写

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

interface Food {
    val count: Int
}
​
class Apple(override val count: Int) : Food
​
class Banana : Food {
    override var count: Int = 0
}