Kotlin 继承

** Any 类**

所有 class  XX 都隐式继承了Any类  ，并且提供了三个默认的 函数

equals()
hashCode()
toString() 

open关键字

如果一个类或者被继承类的属性要被继承或重写，可以使用open 关键字来修饰

open class Example{
       open var a : Int = 0 
}

构造函数

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

   open class Base constructor(name:String,arg:Int){
    }

    class student constructor(name:String,arg:Int,v:Long) : Base(name,arg){
    }

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

/*基类有主构造 */
    open class Base1 constructor(c: Any){
        init {
            Log.v("=====zz=====","基类c=$c")
        }

        constructor(c: Any,name:String) : this(c) {
            Log.v("=====zz=====","基类c=$c , name=$name")
        }
    }

    /*子类无主构造 */
    class student0 : Base1{
        val a = 0
        constructor(c:Any) : super(c){
            Log.v("=====zz=====","子类name=$c")
        }
        constructor(c:Any,b:String) : super(c,b){
            Log.v("=====zz=====","c=$c，b=$b")
        }
    }

    fun s(){
        /*调用*/
        val stu = student0("a")
        val stu1 = student0("a","hello word!")
    }

运行：

重写

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

   open class Base2{
        open fun m1() {
            Log.v("=====Stu1=====","基类的函数")
        }
    }

    class Stu1 : Base2{
        var a : String =  ""
        constructor(a:String):super(){
            this.a=a
        }

        override fun m1() {
            super.m1()
            Log.v("=====Stu1=====","重写基类的函数a = $a")
        }
    }

运行：

如果有多个相同的方法（继承或者实现自其他类，如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();

}

重写属性

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

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

子类继承父类时，不能有跟父类同名的变量，除非父类中该变量为 private，或者父类中该变量为 open 并且子类用 override 关键字重写:

    open class Person(var name: String, var age: Int) {
        open var sex: String = "unknow"
        init {
            println("基类初始化")
        }
    }
    // 如果子类的主构造方法的 name 前边也加了 var，这是不允许的，会报'name' hides member of supertype and needs 'override' modifier
    class Student(name: String, age: Int, var no: String, var score: Int) : Person(name, age) {
        override var sex: String = "male"
    }