Kotlin学习（五）——类的继承（抽象类，覆盖）

Kotlin中继承的根——Any

在 Kotlin 中所有类都有⼀个共同的超类 Any ，这对于没有超类型声明的类是默认超类

class Example // 从 Any 隐式继承

注意：Any 不是 java.lang.Object ；尤其是，它除了 equals() 、hashCode() 和 toString() 外没有任何成员

一般的继承

基类,要想被继承要用open修饰，不然默认就是final的不能被继承。kotlin的设计体现了面向对象设计原则，“要么为被继承而设计，并提供文档说明，要么禁止继承”
要声明⼀个显式的超类型，我们把类型放到类头的冒号之后：

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

继承的不同情况：

有主构造函数的情况：

如果该类有⼀个主构造函数，其基类型可以（并且必须）⽤（基类型的）主构造函数参数就地初始化

请注意是：必须使用主构造函数

open class A(){

}
class SonA():A(){ //直接使用基类的主构造函数初始化基类

}

必须使用也可以是间接的（使用基类次构造函数，因为次构造函数委托主构造函数）

open class A(){
    constructor(name: String):this(){

    }
}

class SonA(name: String):A(name){ //间接使用主构造函数

}

如果类没有主构造函数，那么每个次构造函数必须使⽤ super 关键字初始化其基类型，或委托给另⼀个构造函数做到这⼀点。注意，在这种情况下，不同的次构造函数可以调⽤基类型的不同的构造函数

open class A(){
    constructor(name: String):this(){
    }
}

class SonA:A{ //间接使用主构造函数
    constructor():super(){
    }
    constructor(name: String):super(name){
    }
}

下面是小编自己测试过的
注意：
1. 要不要立即初始化是根据子类有木有主构造函数决定的，根基类无关，就算基类没有主构造，子类有主构造，子类也要立即初始化，只不过立即初始化调用的函数时基类的次构造而已（因为基类的类次构造默认委托无参构造函数）。
2. 有一种特殊情况，如果子类没有主构造也没有次构造，那么也要立即初始化。
3. 初始化调用的函数，不要在意调用的是基类的主构造还是次构造（因为次构造委托了基类的主构造）
下面是一个示例代码：

open class A {
    constructor(name: String){

    }
    constructor(age:Int)
}
class SonA():A(age = 1){ //使用基类的任意次构造函数，立即初始化，也能调用A(name = "la")


}

类上的 open 标注与 Java 中 final 相反，它允许其他类从这个类继承。默认情况下，在 Kotlin 中所有的类都是 final，对应于 Effective Java书中的第17 条：要么为继承⽽设计，并提供⽂档说明，要么就禁⽌继承

覆盖方法

我们之前提到过，Kotlin ⼒求清晰显式。与 Java 不同，Kotlin 需要显式标注可覆盖的成员（我们称之为开放）和覆盖后的成员

open class Base {
    open fun v() {}  //可覆盖的成员
    fun nv() {}
    }
class Derived() : Base() {
    override fun v() {} //覆盖后的成员，因为在封闭的“非open类”中，所以v()不能被子类继承，
    //但是Derived类是open的v()是可以被子类继承的，所以在open类中，v()要用final修饰，避免被覆盖
}

Derived.v() 函数上必须加上 override标注。如果没写，编译器将会报错。如果函数没有标注 open 如 Base.nv() ，则⼦类中不允许定义相同签名的函数，不论加不加 override。在⼀个 final 类中（没有⽤ open 标注的类），开放成员是禁⽌的。
官方原话:标记为 override 的成员本⾝是开放的，也就是说，它可以在⼦类中覆盖。如果你想禁⽌再次覆盖，使⽤ final 关键字

覆盖属性

属性覆盖与⽅法覆盖类似；在超类中声明然后在派⽣类中重新声明的属性必须以 override 开头，并且它们必须具有兼容的类型。每个声明的属性可以由具有初始化器的属性或者具有 getter ⽅法的属性覆盖

open class A(){
    open var age:Int =1
}
class  SonA():A(){
   override var age : Int = 2  //这里我还不理解什么是兼容的类型，只能默认为类型一样（继承Java类要和Java类型兼容）
}

你也可以⽤⼀个 var 属性覆盖⼀个 val 属性，但反之则不⾏。这是允许的，因为⼀个 val 属性本质上声明了⼀个 getter ⽅法，⽽将其覆盖为 var 只是在⼦类中额外声明⼀个 setter ⽅法
下面是正确的：

open class A(){
    open val age:Int =1
}
class  SonA():A(){
   override var age : Int = 2
}

下面是错误的：

open class A(){
    open var age:Int =1
}
class  SonA():A(){
   override varl age : Int = 2 //这里会报错
}

你可以在主构造函数中使⽤ override 关键字作为属性声明的⼀部分

open class A(open val name:String){
    open var age:Int =1
}
class  SonA(override val name:String):A(name){
   override var age : Int = 2 //这里会报错
}

或者：

interface Foo {
    val count: Int
}
class Bar1(override val count: Int) : Foo
class Bar2 : Foo {
    override var count: Int = 0
}

注意：接口中属性要么是抽象的，要么提供访问器实现，而且接口中的属性没有幕后字段。

调用超类的实现（很简单，和Java差不多）

派⽣类中的代码可以使⽤ super 关键字调⽤其超类的函数与属性访问器的实现

open class A(open val name:String){
    open var age:Int =1

    open fun v(){

    }
}
class  SonA(override val name:String):A(name){
    override var age : Int = super.age //调用超类的属性

    override fun v() {
        super.v() //调用超类的方法实现
    }

}

在⼀个内部类中访问外部类的超类，可以通过由外部类名限定的 super 关键字来实现：super@Outer

open class A(open val name:String){
    open var age:Int =1

    open fun v(){

    }
}
class  SonA(override val name:String):A(name){
    override var age : Int = super.age //调用超类的属性

    override fun v() {
        super.v() //调用超类的方法实现
    }

    inner class In {
        fun g(){
            println(super@SonA.age) //调用SonA基类的属性
            super@SonA.v()   //调用SonA基类的方法
        }
    }
}

覆盖规则

在 Kotlin 中，实现继承由下述规则规定：如果⼀个类从它的直接超类继承相同成员的多个实现，它必须覆盖这个成员并提供其⾃⼰的实现（也许⽤继承来的其中之⼀）。为了表⽰采⽤从哪个超类型继承的实现，我们使⽤由尖括号中超类型名限定的 super，如 super
代码如下：

open class DD{
    open fun v(){
        println("DD method v()")
    }
}
interface DD1{
    fun v(){
        println("DD1 method v1()") //这个方法不是可以被继承的，但是和DD类的v()产生了冲突，所以要解决冲突
    }
}

class DD2():DD(),DD1{
    override fun v(){   //类DD2只要继承了接口和类中有相同的方法，这里不覆盖也要覆盖，而且要提供自己的实现，消除歧义
        super<DD1>.v()
    }
}

注意：Kotlin的接口中的函数可以有函数体，和属性一样，要么抽象，要么提供实现

抽象类（和Java很相似，轻快的说）

类和其中的某些成员可以声明为 abstract。抽象成员在本类中可以不⽤实现。需要注意的是，我们并不需要⽤ open 标注⼀个抽象类或者函数⸺因为这不⾔⽽喻

abstract class A {
    abstract fun v()  //用abstract关键字修饰，就是必须被覆盖的,而且本类不要实现
    open fun v1(){  //用open修饰的是可被覆盖的，还要提供实现

    }
}

我们可以⽤⼀个抽象成员覆盖⼀个非抽象的开放成员

open class A {
    open fun v(){
        println("基类的方法")
    }
}
abstract class B :A(){
    override abstract fun v() //这里覆盖了基类的方法，并使之抽象化
}

伴生对象

与 Java 或 C# 不同，在 Kotlin 中类没有静态⽅法。在⼤多数情况下，它建议简单地使⽤包级函数。如果你需要写⼀个可以⽆需⽤⼀个类的实例来调⽤、但需要访问类内部的函数（例如，⼯⼚⽅法），你可以把它写成该类内对象声明中的⼀员。更具体地讲，如果在你的类内声明了⼀个伴生对象，你就可以使⽤像在 Java/C# 中调⽤静态⽅法相同的语法来调⽤其成员，只使⽤类名作为限定符

上面的信息告诉我们：
1. kotlin中没有静态方法。
2. kotlin一般不建议使用伴生对象，而是建议使用包级函数（直接定义在包中kt文件里类之外的函数）。
3. kotlin一般使用伴生对象是要提供工厂方法之类的方法的特殊情况下的。
4. kotlin伴生对象中的方法调用和Java、C#调用静态方法一样
下面看看kotlin怎么调用包级函数：
定义一个包级函数：

package A_clazzAndObject.D_ClassAndObject

fun test(){
    println("包 A_clazzAndObject.D_ClassAndObject里的test()函数被调用了")
}

调用包级的函数：

import A_clazzAndObject.D_ClassAndObject.test  //把方法名import进来

fun main(args: Array<String>) {
    test()
}

伴生对象的示例：

class RR(){
    fun v(){
        println("this is object method")
    }
    companion object Factory{//伴生对想可以取名字，也可以不去名字，伴生对象在一个类里只能有一个
        var rr = RR()  
        fun v1(){
            println("this is companion method")
        }
    }
}
fun main(args: Array<String>) {
    RR.rr.v()
    RR.v1() //调用伴生对象的函数
}

结语：小编写这篇加入了自己的理解，欢迎在评论区点评指正