Kotlin 继承

原文： https://www.programiz.com/kotlin-programming/inheritance

在本文中，您将学习继承。 更具体地说，什么是继承以及如何在 Kotlin 中实现继承（借助示例）。

继承是面向对象编程的主要功能之一。 它允许用户从现有类（基类）创建一个新类（派生类）。

派生类继承了基类的所有功能，并且可以拥有自己的其他功能。

在详细介绍 Kotlin 继承之前，建议您阅读以下两篇文章：

• Kotlin 类和对象
• Kotlin 主要构造器

为什么是继承？

假设在您的应用中，您需要三个字符-一个数学老师，一个足球运动员和一个商人。

由于所有角色都是人，因此他们可以走路和说话。 但是，他们也有一些特殊技能。 数学老师可以教数学，足球运动员可以踢足球，商人可以经营业务。

您可以单独创建三个可以走路，说话和执行其特殊技能的类。

在每个类中，您将为每个角色复制相同的步行和说话代码。

如果要添加新函数eat，则需要为每个字符实现相同的代码。 这很容易导致出错（复制时）和重复代码。

如果我们有一个Person类，它具有基本的功能，例如说话，走路，吃饭，睡觉，并根据我们的角色向这些功能添加特殊技能，那就容易得多。 这是使用继承完成的。

使用继承，现在您不必为每个类的walk()，talk()和eat()实现相同的代码。 您只需要继承它们。

因此，对于MathTeacher（派生类），您可以继承Person（基类）的所有函数并添加新函数teachMath()。 同样，对于Footballer类，您可以继承Person类的所有函数，并添加新函数playFootball()，依此类推。

这使您的代码更简洁，易于理解和可扩展。

重要的是要记住：在处理继承时，每个派生类都应满足“是”基类的条件。 在以上示例中，MathTeacher是Person，Footballer是Person。 您不能有Businessman是Business这类的东西。

Kotlin 继承

让我们尝试在代码中实现以上讨论：

open class Person(age: Int) {
    // code for eating, talking, walking
}
class MathTeacher(age: Int): Person(age) {
    // other features of math teacher
}
class Footballer(age: Int): Person(age) {
    // other features of footballer
}
class Businessman(age: Int): Person(age) {
    // other features of businessman
}

在此，Person是基类，并且MathTeacher，Footballer和Businessman类是从Person类派生的。

注意，在基类Person之前的关键字open。 这一点很重要。

默认情况下，Kotlin 中的类是最终的。 如果您熟悉 Java，那么您将知道最终类不能被子类化。 通过在类上使用开放修饰符，编译器允许您从其派生新类。

示例：Kotlin 继承

open class Person(age: Int, name: String) {
    init {
        println("My name is $name.")
        println("My age is $age")
    }
}
class MathTeacher(age: Int, name: String): Person(age, name) {
    fun teachMaths() {
        println("I teach in primary school.")
    }
}
class Footballer(age: Int, name: String): Person(age, name) {
    fun playFootball() {
        println("I play for LA Galaxy.")
    }
}
fun main(args: Array<String>) {
    val t1 = MathTeacher(25, "Jack")
    t1.teachMaths()
    println()
    val f1 = Footballer(29, "Christiano")
    f1.playFootball()
}

运行该程序时，输出为：

My name is Jack.
My age is 25
I teach in primary school.
My name is Cristiano.
My age is 29
I play for LA Galaxy.

这里，从Person类派生两个类MathTeacher和Footballer。

Person类的主要构造器声明了两个属性：age和name，并且它具有一个初始化块。 基类Person的初始化块（和成员函数）可以由派生类（MathTeacher和Footballer）的对象访问。

派生类MathTeacher和Footballer分别具有自己的成员函数teachMaths()和playFootball()。 这些函数只能从其各自类别的对象中访问。

创建MathTeacher类的对象t1时，

val t1 = MathTeacher(25, "Jack")

参数被传递给主构造器。 在 Kotlin 中，创建对象时会调用init块。 由于MathTeacher是从Person类派生的，因此它将在基类（Person）中查找初始化块并执行它。 如果MathTeacher具有初始化块，则编译器还将执行派生类的初始化块。

接下来，使用t1.teachMaths()语句调用对象t1的teachMaths()函数。

创建Footballer类的对象f1时，程序的工作原理类似。 它执行基类的 init 块。 然后，使用语句f1.playFootball()调用Footballer类的playFootball()方法。

重要说明：Kotlin 继承

• 如果类具有主要构造器，则必须使用主要构造器的参数来初始化基类。 在上面的程序中，两个派生类都有两个参数age和name，并且这两个参数都在基类的主构造器中初始化。
  这是另一个示例： ```kt open class Person(age: Int, name: String) { // some code }

class Footballer(age: Int, name: String, club: String): Person(age, name) { init { println(“Football player $name of age $age and plays for $club.”) }

fun playFootball() {
    println("I am playing football.")
}

}

fun main(args: Array) { val f1 = Footballer(29, “Cristiano”, “LA Galaxy”) }

<br />在此，派生类的主要构造器具有 3 个参数，而基类具有 2 个参数。 请注意，基类的两个参数均已初始化。
- 
在没有主构造器的情况下，每个基类都必须初始化基函数（使用`super`关键字），或者委托给另一个执行该操作的构造器。 例如，
```kt
fun main(args: Array<String>) {
    val p1 = AuthLog("Bad Password")
}
open class Log {
    var data: String = ""
    var numberOfData = 0
    constructor(_data: String) {
    }
    constructor(_data: String, _numberOfData: Int) {
        data = _data
        numberOfData = _numberOfData
        println("$data: $numberOfData times")
    }
}
class AuthLog: Log {
    constructor(_data: String): this("From AuthLog -> + $_data", 10) {
    }
    constructor(_data: String, _numberOfData: Int): super(_data, _numberOfData) {
    }
}

要了解有关该程序如何工作的更多信息，请访问 Kotlin 二级构造器。

覆盖成员的函数和属性

如果基类和派生类包含名称相同的成员函数（或属性），则可能需要使用override关键字覆盖派生类的成员函数，并对基类使用open关键字。

示例：覆盖成员函数

// Empty primary constructor
open class Person() {
    open fun displayAge(age: Int) {
        println("My age is $age.")
    }
}
class Girl: Person() {
    override fun displayAge(age: Int) {
        println("My fake age is ${age - 5}.")
    }
}
fun main(args: Array<String>) {
    val girl = Girl()
    girl.displayAge(31)
}

运行该程序时，输出为：

My fake age is 26.

在此，girl.displayAge(31)调用派生类Girl的displayAge()方法。

您可以通过类似的方式覆盖基类的属性。

在检查以下示例之前，请访问 Kotlin 获取器和设置器在 Kotlin 中的工作方式。

// Empty primary constructor
open class Person() {
    open var age: Int = 0
        get() = field
        set(value) {
            field = value
        }
}
class Girl: Person() {
    override var age: Int = 0
        get() = field
        set(value) {
            field = value - 5
        }
}
fun main(args: Array<String>) {
    val girl = Girl()
    girl.age = 31
    println("My fake age is ${girl.age}.")
}

运行该程序时，输出为：

My fake age is 26.

如您所见，我们分别在派生类和基类中为age属性使用了override和open关键字。

从派生类调用基类成员

您可以使用super关键字从派生类中调用基类的函数（和访问属性）。 这是如何做：

open class Person() {
    open fun displayAge(age: Int) {
        println("My actual age is $age.")
    }
}
class Girl: Person() {
    override fun displayAge(age: Int) {
        // calling function of base class
        super.displayAge(age)
        println("My fake age is ${age - 5}.")
    }
}
fun main(args: Array<String>) {
    val girl = Girl()
    girl.displayAge(31)
}

运行该程序时，输出为：

My age is 31.
My fake age is 26.