Kotlin继承

Kotlin是一种基于JVM的静态类型编程语言，它支持类、接口、抽象类等继承机制。在Kotlin中，继承是通过关键字：来实现的。

继承基础

Kotlin中，一个类可以继承另一个类或者实现一个或多个接口。继承一个类可以使用class关键字后跟类名，而实现一个接口可以使用interface关键字后跟接口名。下面是一个简单的例子：

// 父类 BaseClass
open class BaseClass() {
    fun baseMethod() {
        println("BaseClass method")
    }
}
// 子类 DerivedClass
class DerivedClass() : BaseClass() {
    fun derivedMethod() {
        println("DerivedClass method")
    }
}
// 接口 MyInterface
interface MyInterface {
    fun interfaceMethod()
}
// 实现接口的类
class MyClass() : MyInterface {
    override fun interfaceMethod() {
        println("MyClass method")
    }
}

在上面的例子中，DerivedClass继承了BaseClass，MyClass实现了MyInterface。

重写函数

子类可以重写父类中的函数，使用关键字override。下面是一个简单的例子：

open class BaseClass() {
    open fun baseMethod() {
        println("BaseClass method")
    }
}
class DerivedClass() : BaseClass() {
    override fun baseMethod() {
        println("DerivedClass method")
    }
}

在上面的例子中，BaseClass中的函数baseMethod被DerivedClass重写了。

多重继承

Kotlin不支持多重继承，但是它支持多个接口的实现。下面是一个简单的例子：

interface MyInterface1 {
    fun interfaceMethod1()
}
interface MyInterface2 {
    fun interfaceMethod2()
}
class MyClass() : MyInterface1, MyInterface2 {
    override fun interfaceMethod1() {
        println("MyClass method 1")
    }
    override fun interfaceMethod2() {
        println("MyClass method 2")
    }
}

在上面的例子中，MyClass实现了两个接口MyInterface1和MyInterface2。

抽象类与接口

在Kotlin中，抽象类是使用abstract关键字声明的类，它们不能直接实例化。抽象类可以有抽象方法和非抽象方法，而非抽象方法必须有具体的实现。下面是一个简单的例子：

// 抽象类 BaseClass
abstract class BaseClass {
    abstract fun abstractMethod()
    fun nonAbstractMethod() {
        println("BaseClass non-abstract method")
    }
}
// 继承抽象类的子类
class DerivedClass : BaseClass() {
    override fun abstractMethod() {
        println("DerivedClass abstract method")
    }
}

在上面的例子中，BaseClass是抽象类，DerivedClass是抽象类的子类。

接口是可以包含抽象方法和默认方法的定义。默认情况下，接口的所有方法都是抽象的。下面是一个简单的例子：

// 接口 MyInterface
interface MyInterface {
    fun abstractMethod()

    fun defaultMethod() {
        println("MyInterface default method")
    }
}
// 实现接口的类
class MyClass : MyInterface {
    override fun abstractMethod() {
        println("MyClass abstract method")
    }
}

在上面的例子中，MyClass实现了MyInterface接口的所有方法。

至此，Kotlin继承相关的介绍结束。