Kotlin 继承和接口

朴灿烈づ我的快乐病毒、 2022-04-23 13:24 384阅读 0赞

一、Kotlin中类的继承

在Java中，类基于Object，而在Kotlin中类基于Any,所有类都默认继承Any。kotlin中的类默认是final类型的，不可被继承，想要作为基类被继承必须使用open关键字修饰。

对于没有超类型声明的类默认超类是Any，Any类只有三个函数~

package kotlin
    
    public open class Any {
       
        public open operator fun equals(other: Any?): Boolean
    
        public open fun hashCode(): Int
    
        public open fun toString(): String
    }

二、子类对构造函数的实现

1.当子类中有构造函数，则基类必须在主构造函数中立即初始化

open class S(name: String, age: Int) { //基类
    
    }
    
    //子类中有构造函数，则基类必须在主构造函数中立即初始化
    class SS(var name: String, val age: Int, val score: Int) : S(name, age) {
    
    }
    fun main(args: Array<String>) {
        val s = SS("Tina", 20, 60)
        println("学生名：${s.name}")
        println("年龄：${s.age}")
        println("成绩：${s.score}")
    
    }
    学生名：Tina
    年龄：20
    成绩：60

2.当子类中没有主构造函数时，则必须每一个次要构造函数或代理另一个构造函数中用 super 关键字初始化基类。初始化基类时，可以使用super来调用基类的不同构造函数。

open class Personal(name: String) {
        constructor(name: String, age: Int) : this(name) {
            //初始化
            println("---基类次级构造函数-----")
        }
    }
    
    class SrudentImpl : Personal {
        constructor(name: String, age: Int, no: String, score: Int, likely: String) : super(name, age) {
            println("----- 继承类的次级构造函数 ------")
            println("学生名:${name}")
            println("年龄：${age}")
            println("学生号：${no}")
            println("成绩:${score}")
        }
    }
    fun main(args: Array<String>) {
        var student = SrudentImpl("Mikle", 18, "12485684", 98, "唱歌")
    }
    学生名:Mikle
    年龄：18
    学生号：12485684
    成绩:98

3.方法的重写

基类中，使用fun声明函数时，该函数默认是final修饰的，不能被子类重写。如果允许该函数能被重写，则需手动添加open修饰它，子类复写使用override关键词。

open class D {
        open fun study() {  //允许子类重写的方法
            println("基类DD中定义需被子类重写的方法")
        }
    }
    
    class DD : D(), F {
        override fun study() {
            println("子类重写了父类的方法~~~")
            super<D>.study()
            super<F>.study()
        }
    }
    
    interface F {
        fun study() {  //允许子类重写的方法
            println("接口F中定义的方法~~")
        }
    }

4.属性重写：使用override关键字

interface Foo {
        val count: Int
    }
    
    //属性的复写使用override关键字
    class Bar1(override val count: Int) : Foo {}
    
    class Bar2 : Foo {
        override var count: Int = 0
    }

三、Kotlin中接口的实现

使用关键字interface定义接口，一个类可实现一个或多个接口

interface MyInterface {
        val name:String  //接口中的属性只能是抽象的，不允许初始化值，实现接口，必须重写属性
        fun bar()
        fun foo()
    }
    
    class Child: MyInterface {
        override var name:String="我是复写的name属性"  //重写属性
        override fun foo() {
            println("调用了foo方法")
        }
    
        override fun bar() {
           println("调用了bar方法")
        }
    }
    
    fun main(args: Array<String>) {
        val c = Child()
        c.foo()
        c.bar()
        println(c.name)
    }
    调用了foo方法
    调用了bar方法
    我是复写的name属性

\*\*\*当实现多个接口时，可能会遇到同一方法继承多个实现的问题。

interface A {
        fun foo() {
            println("A")
        }  //有方法体，代表已经实现
    
        fun bar() //无方法体，是抽象的，未实现，需要被子类重写
    }
    
    interface B {
        fun foo() {
            println("B") //已实现
        }
    
        fun bar() {
            println("bar") //已实现
        }
    }
    
    class C : A {
        override fun bar() {
        }
    }
    
    class H : A, B {
        override fun bar() {
            super<B>.bar()
        }
    
        override fun foo() {
            super<A>.foo()
            super<B>.foo()
        }
    }
    
    fun main(args: Array<String>) {
       val h=H()
        h.foo()
        h.bar()
    }
    调用了foo方法
    调用了bar方法
    我是复写的name属性