Kotlin 继承

2024年8月29日 | 阅读 7 分钟

继承是面向对象编程语言的一个重要特性。继承允许将现有类（或基类或父类）的特性继承到新类（或派生类或子类）中。

主类称为超类（或父类），而继承超类的类称为子类（或子类）。子类包含超类的特性以及其自身的特性。

当两个或多个类具有相同属性时，允许使用继承的概念。它允许代码重用。派生类只有一个基类，但可以有多个接口，而基类可以有一个或多个派生类。

在 Kotlin 中，派生类使用以下方式继承基类：在类头中（在派生类名或构造函数之后）使用运算符

open class Base(p: Int){

}
class Derived(p: Int) : Base(p){

}

假设我们有两个不同的类“程序员”和“推销员”，它们具有共同的属性“姓名”、“年龄”和“薪水”，以及它们各自的单独功能 doProgram() 和 fieldWork()。继承的特性允许我们继承（Employee）包含共同的特性。

open class Employee(name: String, age: Int, salary: Float) {
    // code of employee
}

class Programmer(name: String, age: Int, salary: Float): Employee(name,age,salary) {
    // code of programmer
}

class Salesman(name: String, age: Int, salary: Float): Employee(name,age,salary) {
    // code of salesman
}

所有 Kotlin 类都有一个共同的超类“Any”。对于未显式指定超类型的类，它是默认的超类。

例如，一个 Example 类隐式地从 Any 继承。

Kotlin open 关键字

由于 Kotlin 类默认是final 的，因此它们不能简单地被继承。我们使用 open 关键字在类之前继承一个类并使其为非 final，

例如

open class Example{
// I can now be extended!
}

Kotlin 从一个类继承字段

当我们继承一个类来派生类时，所有字段和功能都会被继承。我们可以在派生类中使用这些字段和功能。

例如

open class Base{
val x = 10
}
class Derived: Base() {
    fun foo() {
println("x is equal to " + x)
    }
}
fun main(args: Array<String>) {
val derived = Derived()
    derived.foo() 
}

输出

x is equal to 10

Kotlin 从一个类继承方法

open class Bird {
    fun fly() {
println("flying...")
    }
}
class Duck: Bird() {
    fun swim() {
println("swimming...")
    }
}
fun main(args: Array<String>) {
val duck = Duck()
    duck.fly() 
duck.swim()
}

输出

flying...
swimming...

Kotlin 继承示例

在这里，我们声明了一个 Employee 类作为超类，而 Programmer 和 Salesman 是它们的子类。子类继承属性名称、年龄和薪水，以及子类包含它们自己的功能，例如 doProgram() 和 fieldWork()。

open class Employee(name: String, age: Int, salary: Float) {
init {
println("Name is $name.")
println("Age is $age")
println("Salary is $salary")
    }
}
class Programmer(name: String, age: Int, salary: Float):Employee(name,age,salary){
    fun doProgram() {
println("programming is my passion.")
    }
}
class Salesman(name: String, age: Int, salary: Float):Employee(name,age,salary){
    fun fieldWork() {
println("travelling is my hobby.")
    }
}
fun main(args: Array<String>){
val obj1 = Programmer("Ashu", 25, 40000f)
    obj1.doProgram()
val obj2 = Salesman("Ajay", 24, 30000f)
    obj2.fieldWork()
}

输出

Name is Ashu.
Age is 25
Salary is 40000.0
programming is my passion.
Name is Ajay.
Age is 24
Salary is 30000.0
travelling is my hobby.

Kotlin 继承和主构造函数

如果基类和派生类都具有主构造函数，在这种情况下，参数将在基类的主构造函数中初始化。在上面的继承示例中，所有类都包含三个参数“姓名”、“年龄”和“薪水”，并且所有这些参数都在基类的主构造函数中初始化。

当基类和派生类在其主构造函数中都包含不同数量的参数时，则基类参数从派生类对象初始化。

例如

open class Employee(name: String,salary: Float) {
init {
println("Name is $name.")
println("Salary is $salary")
    }
}
class Programmer(name: String, dept: String, salary: Float):Employee(name,salary){
init {
println("Name $name of department $dept with salary $salary.")
    }
    fun doProgram() {
println("Programming is my passion.")

    }
}
class Salesman(name: String, dept: String, salary: Float):Employee(name,salary){
init {
println("Name $name of department $dept with salary $salary.")
    }
    fun fieldWork() {
println("Travelling is my hobby.")

    }
}
fun main(args: Array<String>){
val obj1 = Programmer("Ashu", "Development", 40000f)
    obj1.doProgram()
println()
val obj2 = Salesman("Ajay", "Marketing", 30000f)
    obj2.fieldWork()
}

输出

Name is Ashu.
Salary is 40000.0
Name Ashu of department Development with salary 40000.0.
Programming is my passion.

Name is Ajay.
Salary is 30000.0
Name Ajay of department Marketing with salary 30000.0.
Travelling is my hobby.

当创建派生类的对象时，它首先调用其超类，并执行基类的 init 块，然后执行其自身的。

Kotlin 继承和辅助构造函数

如果派生类不包含任何主构造函数，则需要使用 super 关键字从派生类调用基类辅助构造函数。

例如：

open class Patent {

    constructor(name: String, id: Int) {
println("execute super constructor $name: $id")
    }
}

class Child: Patent {

    constructor(name: String, id: Int, dept: String): super(name, id) {
        print("execute child class constructor with property $name, $id, $dept")
    }
}
fun main(args: Array<String>) {
val child = Child("Ashu",101, "Developer")
}

输出

execute super constructor Ashu: 101
execute child class constructor with property Ashu, 101, Developer

在上面的例子中，当创建 Child 类的对象时，它会调用它的构造函数并使用值“Ashu”、“101”和“Developer”初始化它的参数。与此同时，Child 类构造函数使用 super 关键字调用其超类构造函数，其中包含名称和 ID 的值。由于 super 关键字的存在，超类构造函数的主体首先执行，然后返回到 Child 类构造函数。

Kotlin 方法重写

方法重写意味着将超（父）类的方法的特定实现提供给其子类（子）类。

换句话说，当子类在子类中重新定义或修改其超类的方法时，这称为方法重写。方法重写仅在继承中才可能。

Kotlin 方法重写的规则

父类及其要重写的方法或属性必须是 open (非 final)。
基类和派生类的方法名称必须相同。
方法必须具有与基类中相同的参数。

没有重写的继承示例

open class Bird {
    open fun fly() {
println("Bird is flying...")
    }
}
class Parrot: Bird() {

}
class Duck: Bird() {

}
fun main(args: Array<String>) {
val p = Parrot()
    p.fly()
val d = Duck()
    d.fly()
}

输出

Bird is flying...
Bird is flying...

在上面的示例中，在没有重写基类的方法的情况下，我们发现两个派生类 Parrot 和 Duck 执行相同的公共操作。为了克服这个问题，我们使用了方法重写的概念。

Kotlin 方法重写示例

在此示例中，父类 Bird 的方法 fly() 在其子类 Parrot 和 Duck 中被重写。要重写父类的方法，必须将父类及其要重写的方法声明为 open。同时，在子类中被重写的方法必须以关键字 override 开头。

open class Bird {
    open fun fly() {
println("Bird is flying...")
    }
}
class Parrot: Bird() {
    override fun fly() {
println("Parrot is flying...")
    }
}
class Duck: Bird() {
    override fun fly() {
println("Duck is flying...")
    }
}
fun main(args: Array<String>) {
val p = Parrot()
    p.fly()
val d = Duck()
    d.fly()
}

输出

Parrot is flying...
Duck is flying...

Kotlin 属性重写示例

超类的属性也可以在其子类中重写，类似于方法。 Bird 类的 color 属性在其子类 Parrot 和 Duck 中被重写并修改。

open class Bird {
    open var color = "Black"
    open fun fly() {
println("Bird is flying...")
    }
}
class Parrot: Bird() {
    override var color = "Green"
    override fun fly() {
println("Parrot is flying...")
    }
}
class Duck: Bird() {
    override var color = "White"
    override fun fly() {
println("Duck is flying...")
    }
}
fun main(args: Array<String>) {
val p = Parrot()
    p.fly()
println(p.color)
val d = Duck()
    d.fly()
println(d.color)
}

输出

Parrot is flying...
Green
Duck is flying...
White

我们可以在继承中用 var 属性覆盖 val 属性，但反之则不成立。

Kotlin 超类实现

派生类也可以使用 super 关键字调用其超类方法和属性。

例如

open class Bird {
    open var color = "Black"
    open fun fly() {
println("Bird is flying...")
    }
}
class Parrot: Bird() {
    override var color = "Green"
    override fun fly() {
        super.fly()
println("Parrot is flying...")

    }
}

fun main(args: Array<String>) {
val p = Parrot()
    p.fly()
println(p.color)

}

输出

Bird is flying...
Parrot is flying...
Green

Kotlin 多类实现

在 Kotlin 中，当它实现多个类中提供的相同函数名称时，派生类使用尖括号中的超类型名称，例如 super<Base>。

例如，派生类 Parrotextends 其超类 Bird 并实现包含相同函数 fly() 的 Duck 接口。要调用每个类和接口的特定方法，我们必须在尖括号中提及超类型名称，例如 super<Bird>.fly() 和 super<Duck>.fly() 用于每个方法。

open class Bird {
    open var color = "Black"
    open fun fly() {
println("Bird is flying...")
    }
}
interface Duck {
     fun fly() {
println("Duck is flying...")
    }
}
class Parrot: Bird(),Duck {
    override var color = "Green"
    override fun fly() {
        super<Bird>.fly()
        super<Duck>.fly()
println("Parrot is flying...")

    }
}
fun main(args: Array<String>) {
val p = Parrot()
    p.fly()
println(p.color)

}

输出

Bird is flying...
Duck is flying...
Parrot is flying...

下一主题Kotlin 抽象类

Kotlin 继承

Kotlin open 关键字

Kotlin 从一个类继承字段

Kotlin 从一个类继承方法

Kotlin 继承示例

Kotlin 继承和主构造函数

Kotlin 继承和辅助构造函数

Kotlin 方法重写

没有重写的继承示例

Kotlin 方法重写示例

Kotlin 属性重写示例

Kotlin 超类实现

Kotlin 多类实现

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Kotlin 教程

控制流

函数

Array

String

异常处理

Null 安全

集合

注解

反射

Kotlin OOPs

范围

Java 互操作性

Regex

Android 启动

Kotlin Android

Kotlin 继承

Kotlin open 关键字

Kotlin 从一个类继承字段

Kotlin 从一个类继承方法

Kotlin 继承示例

Kotlin 继承和主构造函数

Kotlin 继承和辅助构造函数

Kotlin 方法重写

没有重写的继承示例

Kotlin 方法重写示例

Kotlin 属性重写示例

Kotlin 超类实现

Kotlin 多类实现

相关帖子

数据类

抽象类

可见性修饰符

Kotlin 接口

Kotlin 泛型

Kotlin 构造函数

扩展函数

嵌套和内部类

类和对象

密封类

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器