Kotlin学习之 8继承

浅浅的花香味﹌ 2022-05-25 23:58 215阅读 0赞

# Kotlin 继承 #

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

class Example // 从 Any 隐式继承

### Any 默认提供了三个函数： ###

equals()
    
    hashCode()
    
    toString()

Kotlin中没有Object这个类。Any是不是和Java中的Object是非常相似的。并且Object也是只提供上面三个方法。  
注意：Any 不是 java.lang.Object。

如果一个类要被继承，可以使用 open 关键字进行修饰。

open class Base(p: Int)           // 定义基类
    
    class Derived(p: Int) : Base(p)  //继承Base的类的参数要包含Base类的参数

## 二.构造函数 ##

### 1.子类有主构造函数 ###

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

open class Person(var name : String, var age : Int){
       // 父类
    
    }
    
    class Student(name : String, age : Int, var no : String, var score : Int) : Person(name, age) { //子类
    
    }
    
    // 测试
    fun main(args: Array<String>) {
        val s =  Student("Runoob", 18, "S12346", 89)//子类实现的时候，进行初始化数据
        println("学生名： ${s.name}")
        println("年龄： ${s.age}")
        println("学生号： ${s.no}")
        println("成绩： ${s.score}")
    }

#### 运行结果： ####

学生名： Runoob
    年龄： 18
    学生号： S12346
    成绩： 89

### 2.子类没有主构造函数 ###

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

class Student : Person {
    
        constructor(ctx: Context) : super(ctx) {
        } 
    
        constructor(ctx: Context, attrs: AttributeSet) : super(ctx,attrs) {
        }
    }

#### 实例 ####

/**用户基类**/
    open class Person(name:String){ //父类
        /**次级构造函数**/
        constructor(name:String,age:Int):this(name){
            //初始化
            println("-------基类次级构造函数---------")
        }
    }
    
    /**子类继承 Person 类**/
    class Student:Person{ //子类没有主构造方法
    
        /**次级构造函数**/
        constructor(name:String,age:Int,no:String,score:Int):super(name,age){
            println("-------继承类次级构造函数---------")
            println("学生名： ${name}")
            println("年龄： ${age}")
            println("学生号： ${no}")
            println("成绩： ${score}")
        }
    }
    
    fun main(args: Array<String>) {
        var s =  Student("Runoob", 18, "S12345", 89)
    }

#### 输出结果： ####

-------基类次级构造函数---------
    -------继承类次级构造函数---------
    学生名： Runoob
    年龄： 18
    学生号： S12345
    成绩： 89

这个没什么好说的，看一遍也基本能理解。

## 三.重写 ##

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

/**用户基类**/
    open class Person{
        open fun study(){       // 允许子类重写
            println("我毕业了")
        }
    }
    
    /**子类继承 Person 类**/
    class Student : Person() {
    
        override fun study(){    // 重写方法
            println("我在读大学")
        }
    }
    
    //测试
    fun main(args: Array<String>) {
        val s =  Student()
        s.study();
    
    }

### 输出结果为: ###

我在读大学

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

package hello                      
    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关键字
            super<B>.f()//调用 B.f()
        }
    
        fun doOther(){ //自定义方法
            a() //这里a（）方法虽然不能重写，但是在子类中调用是没有问题的
            b()
        }
    
    }
    ?
    fun main(args: Array<String>) {
        val c =  C()
        c.f();
        c.doOther()
    }

C 继承自 a() 或 b(), C 不仅可以从 A 或则 B 中继承函数，而且 C 可以继承 A()、B() 中共有的函数。  
此时该函数在中只有一个实现，为了消除歧义，该函数必须调用A()和B()中该函数的实现，并提供自己的实现。

#### 输出结果为: ####

ABab

其实这个重写Kotlin和java的方式差不多的，就是会有关键字的不同。

## 四.属性重写 ##

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

open class Foo {
       //父类
        open val x: Int get { …… }//定义属性
    }
    
    class Bar1 : Foo() {
       //子类
        override val x: Int = ……  //覆盖属性，重写属性
    }

你可以用一个var属性重写一个val属性，但是反过来不行。  
因为val属性本身定义了getter方法，重写为var属性会在衍生类中额外声明一个setter方法

这个跟我刚开始理解的居然有点不一样。  
其实可以像java那样理解，父类的方法的修饰符如果是protect，那么子类中重写这个方法，修饰符只能是protect或者public，总之要不父类的范围广。

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

package hello                      //  可选的包头
    interface Foo {
       //父类
        val count: Int
        var number:Int
    }
    
    class Bar1(override val count: Int,override var number:Int) : Foo //子类，在构造方法中重写属性
    
    class Bar2 : Foo {
        override var count: Int = 0 //在类中重写属性,使用var重写val属性是没有问题的
        override var number:Int=2   //如果这里使用val就会报错
    }
    
    fun main(args: Array<String>) {
        val bar2=Bar2()
        var c= bar2.count //后面类型是无所谓的
        println("c=$c")
        val d=bar2.number //后面类型是无所谓的
        println("d=$d")
    }

### 运行结果： ###

c=0
    d=2

上面示例中父类是接口，所以每一个属性都是要必须被重写的。如果父类是简单的类，可以只重写open的属性和方法。

但是我感觉这样写，如果Kotlin中接口的属性比较多，这不是很坑吗！

继承关系到这里就简单介绍完毕了，大家也可以测试一下：  
[https://blog.csdn.net/wenzhi20102321/article/details/79859347][https_blog.csdn.net_wenzhi20102321_article_details_79859347]

# 共勉：还有好多路要走 #

[https_blog.csdn.net_wenzhi20102321_article_details_79859347]: https://blog.csdn.net/wenzhi20102321/article/details/79859347