Skip to content

Open 类与特殊类 ​

在本章中,你将学习 open 类、它们如何与接口协同工作,以及 Kotlin 中提供的其他特殊类型的类。

Open 类 ​

如果无法使用接口或抽象类,你可以通过将类声明为 open,显式使其可被继承。 为此,请在类声明前使用 open 关键字:

kotlin
open class Vehicle(val make: String, val model: String)

要创建继承自另一个类的类,请在类头后添加一个冒号,后接要继承的父类构造函数的调用。在此示例中,Car 类继承自 Vehicle 类:

kotlin
open class Vehicle(val make: String, val model: String)

class Car(make: String, model: String, val numberOfDoors: Int) : Vehicle(make, model)

fun main() {
    // 创建 Car 类的实例
    val car = Car("Toyota", "Corolla", 4)

    // 打印汽车的详细信息
    println("Car Info: Make - ${car.make}, Model - ${car.model}, Number of doors - ${car.numberOfDoors}")
    // Car Info: Make - Toyota, Model - Corolla, Number of doors - 4
}

就像创建普通类实例一样,如果你的类继承自父类,则必须初始化父类类头中声明的所有形参。因此在示例中,Car 类的 car 实例初始化了父类形参:make 和 model。

重写继承的行为 ​

如果你想继承某个类但更改其部分行为,可以重写继承的行为。

默认情况下,无法重写父类的成员函数或属性。就像抽象类一样,你需要添加特殊的关键字。

成员函数 ​

若要允许父类中的函数被重写,请在父类中的函数声明前使用 open 关键字:

kotlin
open fun displayInfo() {}

若要重写继承的成员函数,请在子类中的函数声明前使用 override 关键字:

kotlin
override fun displayInfo() {}

例如:

kotlin
open class Vehicle(val make: String, val model: String) {
    open fun displayInfo() {
        println("Vehicle Info: Make - $make, Model - $model")
    }
}

class Car(make: String, model: String, val numberOfDoors: Int) : Vehicle(make, model) {
    override fun displayInfo() {
        println("Car Info: Make - $make, Model - $model, Number of Doors - $numberOfDoors")
    }
}

fun main() {
    val car1 = Car("Toyota", "Corolla", 4)
    val car2 = Car("Honda", "Civic", 2)

    // 使用重写后的 displayInfo() 函数
    car1.displayInfo()
    // Car Info: Make - Toyota, Model - Corolla, Number of Doors - 4
    car2.displayInfo()
    // Car Info: Make - Honda, Model - Civic, Number of Doors - 2
}

此示例:

  • 创建了继承自 Vehicle 类的两个 Car 类实例:car1 和 car2。
  • 重写了 Car 类中的 displayInfo() 函数,使其同时打印车门数量。
  • 在 car1 和 car2 实例上调用重写后的 displayInfo() 函数。

属性 ​

在 Kotlin 中,使用 open 关键字使属性可继承并在之后重写它并不是常见做法。大多数情况下,你会使用抽象类或接口,在其中属性默认是可继承的。

open 类中的属性可以由其子类访问。通常,直接访问它们比使用新属性重写它们更好。

例如,假设你有一个名为 transmissionType 的属性,想要稍后重写它。重写属性的语法与重写成员函数完全相同。你可以这样做:

kotlin
open class Vehicle(val make: String, val model: String) {
    open val transmissionType: String = "Manual"
}

class Car(make: String, model: String, val numberOfDoors: Int) : Vehicle(make, model) {
    override val transmissionType: String = "Automatic"
}

然而,这并不是一种良好的实践。相反,你可以将该属性添加到可继承类的构造函数中,并在创建 Car 子类时声明其值:

kotlin
open class Vehicle(val make: String, val model: String, val transmissionType: String = "Manual")

class Car(make: String, model: String, val numberOfDoors: Int) : Vehicle(make, model, "Automatic")

直接访问属性而不是重写它们,可以使代码更简单、更具可读性。通过在父类中声明一次属性并通过构造函数传递其值,你可以消除在子类中进行不必要重写的需求。

有关类继承和重写类行为的更多信息,请参阅继承。

Open 类与接口 ​

你可以创建一个既继承类又实现多个接口的类。在这种情况下,必须在冒号后首先声明父类,然后再列出接口:

kotlin
// 定义接口
interface EcoFriendly {
    val emissionLevel: String
}

interface ElectricVehicle {
    val batteryCapacity: Double
}

// 父类
open class Vehicle(val make: String, val model: String)

// 子类
open class Car(make: String, model: String, val numberOfDoors: Int) : Vehicle(make, model)

// 继承自 Car 并实现两个接口的新类
class ElectricCar(
    make: String,
    model: String,
    numberOfDoors: Int,
    val capacity: Double,
    val emission: String
) : Car(make, model, numberOfDoors), EcoFriendly, ElectricVehicle {
    override val batteryCapacity: Double = capacity
    override val emissionLevel: String = emission
}

特殊类 ​

除了抽象类、open 类和数据类之外,Kotlin 还提供了专为各种目的设计的特殊类型的类,例如限制特定行为或降低创建小型对象的性能开销。

密封类 ​

有时你可能会希望限制继承。你可以使用密封类来实现这一点。密封类是一种特殊类型的抽象类。一旦将类声明为密封类,你就只能在同一个包内创建它的子类。在该作用域之外无法继承该密封类。

包是包含相关类和函数的代码集合,通常位于一个目录内。要了解更多关于 Kotlin 中包的信息,请参阅包与导入。

要创建密封类,请使用 sealed 关键字:

kotlin
sealed class Mammal

密封类在与 when 表达式结合使用时特别有用。通过使用 when 表达式,你可以为所有可能的子类定义行为。例如:

kotlin
sealed class Mammal(val name: String)

class Cat(val catName: String) : Mammal(catName)
class Human(val humanName: String, val job: String) : Mammal(humanName)

fun greetMammal(mammal: Mammal): String {
    when (mammal) {
        is Human -> return "Hello ${mammal.name}; You're working as a ${mammal.job}"
        is Cat -> return "Hello ${mammal.name}"   
    }
}

fun main() {
    println(greetMammal(Cat("Snowy")))
    // Hello Snowy
}

在此示例中:

  • 有一个名为 Mammal 的密封类,其构造函数中带有 name 形参。
  • Cat 类继承自 Mammal 密封类,并在其自己的构造函数中使用 catName 形参作为来自 Mammal 类的 name 形参。
  • Human 类继承自 Mammal 密封类,并在其自己的构造函数中使用 humanName 形参作为来自 Mammal 类的 name 形参。它的构造函数中还有一个 job 形参。
  • greetMammal() 函数接收一个 Mammal 类型的实参并返回一个字符串。
  • 在 greetMammal() 函数体内,有一个 when 表达式,它使用 is 运算符来检查 mammal 的类型并决定执行哪个操作。
  • main() 函数使用 Cat 类的实例以及名为 Snowy 的 name 形参调用了 greetMammal() 函数。

本教程在空安全一章中更详细地讨论了 is 运算符。

有关密封类及其推荐用例的更多信息,请参阅密封类与接口。

枚举类 ​

当你希望在类中表示有限的离散值集合时,枚举类非常有用。枚举类包含枚举常量,它们本身就是该枚举类的实例。

要创建枚举类,请使用 enum 关键字:

kotlin
enum class State

假设你想要创建一个包含流程不同状态的枚举类。每个枚举常量必须用逗号 , 分隔:

kotlin
enum class State {
    IDLE, RUNNING, FINISHED
}

State 枚举类包含以下枚举常量:IDLE、RUNNING 和 FINISHED。要访问枚举常量,请使用类名后跟 . 以及枚举常量的名称:

kotlin
val state = State.RUNNING

你可以将此枚举类与 when 表达式结合使用,根据枚举常量的值来定义要执行的操作:

kotlin
enum class State {
    IDLE, RUNNING, FINISHED
}

fun main() {
    val state = State.RUNNING
    val message = when (state) {
        State.IDLE -> "It's idle"
        State.RUNNING -> "It's running"
        State.FINISHED -> "It's finished"
    }
    println(message)
    // It's running
}

枚举类可以像普通类一样拥有属性和成员函数。

例如,假设你正在处理 HTML 并希望创建一个包含某些颜色的枚举类。 你希望每种颜色都有一个属性(我们称之为 rgb),该属性包含其十六进制形式的 RGB 值。 在创建枚举常量时,必须使用该属性对其进行初始化:

kotlin
enum class Color(val rgb: Int) {
    RED(0xFF0000),
    GREEN(0x00FF00),
    BLUE(0x0000FF),
    YELLOW(0xFFFF00)
}

Kotlin 将十六进制数存储为整数,因此 rgb 属性的类型为 Int,而不是 String。

要向此类添加成员函数,请使用分号 ; 将其与枚举常量分隔开:

kotlin
enum class Color(val rgb: Int) {
    RED(0xFF0000),
    GREEN(0x00FF00),
    BLUE(0x0000FF),
    YELLOW(0xFFFF00);

    fun containsRed() = (this.rgb and 0xFF0000 != 0)
}

fun main() {
    val red = Color.RED
    
    // 在枚举常量上调用 containsRed() 函数
    println(red.containsRed())
    // true

    // 通过类名在枚举常量上调用 containsRed() 函数
    println(Color.BLUE.containsRed())
    // false
  
    println(Color.YELLOW.containsRed())
    // true
}

在此示例中,containsRed() 成员函数使用 this 关键字访问枚举常量的 rgb 属性值,并检查该十六进制值的前几个位是否包含 FF,从而返回一个布尔值。

更多信息请参阅枚举类。

内联值类 ​

有时在代码中,你可能希望根据类创建小型对象且仅短暂使用它们。这种做法可能会带来性能影响。内联值类是一种可以避免此类性能影响的特殊类。但是,它们只能包含值。

要创建内联值类,请使用 value 关键字和 @JvmInline 注解:

kotlin
@JvmInline
value class Email

@JvmInline 注解指示 Kotlin 在编译时对代码进行优化。要了解更多信息,请参阅注解。

内联值类必须在类头中初始化单个属性。

假设你想创建一个用于收集电子邮件地址的类:

kotlin
// address 属性在类头中初始化。
@JvmInline
value class Email(val address: String)

fun sendEmail(email: Email) {
    println("Sending email to ${email.address}")
}

fun main() {
    val myEmail = Email("example@example.com")
    sendEmail(myEmail)
    // Sending email to example@example.com
}

在此示例中:

  • Email 是一个内联值类,其类头中有一个属性:address。
  • sendEmail() 函数接收类型为 Email 的对象,并将字符串打印到标准输出。
  • main() 函数:
    • 创建了名为 myEmail 的 Email 类实例。
    • 在 myEmail 对象上调用 sendEmail() 函数。

通过使用内联值类,你可以使类内联,并在代码中直接使用它而无需创建对象。这可以显著减少内存占用并提高代码的运行时性能。

有关内联值类的更多信息,请参阅内联值类。

练习 ​

使用密封类为派送状态建模

你管理着一项派送服务,需要一种方法来跟踪包裹的状态。创建一个名为 DeliveryStatus 的密封类,其中包含表示以下状态的数据类:Pending、InTransit、Delivered、Canceled。补全 DeliveryStatus 类声明,使 main() 函数中的代码能够成功运行:

kotlin
sealed class // 在此处编写你的代码

fun printDeliveryStatus(status: DeliveryStatus) {
    when (status) {
        is DeliveryStatus.Pending -> {
            println("The package is pending pickup from ${status.sender}.")
        }
        is DeliveryStatus.InTransit -> {
            println("The package is in transit and expected to arrive by ${status.estimatedDeliveryDate}.")
        }
        is DeliveryStatus.Delivered -> {
            println("The package was delivered to ${status.recipient} on ${status.deliveryDate}.")
        }
        is DeliveryStatus.Canceled -> {
            println("The delivery was canceled due to: ${status.reason}.")
        }
    }
}

fun main() {
    val status1: DeliveryStatus = DeliveryStatus.Pending("Alice")
    val status2: DeliveryStatus = DeliveryStatus.InTransit("2024-11-20")
    val status3: DeliveryStatus = DeliveryStatus.Delivered("2024-11-18", "Bob")
    val status4: DeliveryStatus = DeliveryStatus.Canceled("Address not found")

    printDeliveryStatus(status1)
    // The package is pending pickup from Alice.
    printDeliveryStatus(status2)
    // The package is in transit and expected to arrive by 2024-11-20.
    printDeliveryStatus(status3)
    // The package was delivered to Bob on 2024-11-18.
    printDeliveryStatus(status4)
    // The delivery was canceled due to: Address not found.
}
参考解决方案 {...}
kotlin
sealed class DeliveryStatus {
    data class Pending(val sender: String) : DeliveryStatus()
    data class InTransit(val estimatedDeliveryDate: String) : DeliveryStatus()
    data class Delivered(val deliveryDate: String, val recipient: String) : DeliveryStatus()
    data class Canceled(val reason: String) : DeliveryStatus()
}

fun printDeliveryStatus(status: DeliveryStatus) {
    when (status) {
        is DeliveryStatus.Pending -> {
            println("The package is pending pickup from ${status.sender}.")
        }
        is DeliveryStatus.InTransit -> {
            println("The package is in transit and expected to arrive by ${status.estimatedDeliveryDate}.")
        }
        is DeliveryStatus.Delivered -> {
            println("The package was delivered to ${status.recipient} on ${status.deliveryDate}.")
        }
        is DeliveryStatus.Canceled -> {
            println("The delivery was canceled due to: ${status.reason}.")
        }
    }
}

fun main() {
    val status1: DeliveryStatus = DeliveryStatus.Pending("Alice")
    val status2: DeliveryStatus = DeliveryStatus.InTransit("2024-11-20")
    val status3: DeliveryStatus = DeliveryStatus.Delivered("2024-11-18", "Bob")
    val status4: DeliveryStatus = DeliveryStatus.Canceled("Address not found")

    printDeliveryStatus(status1)
    // The package is pending pickup from Alice.
    printDeliveryStatus(status2)
    // The package is in transit and expected to arrive by 2024-11-20.
    printDeliveryStatus(status3)
    // The package was delivered to Bob on 2024-11-18.
    printDeliveryStatus(status4)
    // The delivery was canceled due to: Address not found.
}
使用枚举类定义问题类型

在程序中,你希望能够处理不同的状态和错误类型。你有一个密封类用于捕获在数据类或对象中声明的不同状态。通过创建一个名为 Problem 的枚举类来表示不同的问题类型(NETWORK、TIMEOUT 和 UNKNOWN),补全以下代码。

kotlin
sealed class Status {
    data object Loading : Status()
    data class Error(val problem: Problem) : Status() {
        // 在此处编写你的代码
    }

    data class OK(val data: List<String>) : Status()
}

fun handleStatus(status: Status) {
    when (status) {
        is Status.Loading -> println("Loading...")
        is Status.OK -> println("Data received: ${status.data}")
        is Status.Error -> when (status.problem) {
            Status.Error.Problem.NETWORK -> println("Network issue")
            Status.Error.Problem.TIMEOUT -> println("Request timed out")
            Status.Error.Problem.UNKNOWN -> println("Unknown error occurred")
        }
    }
}

fun main() {
    val status1: Status = Status.Error(Status.Error.Problem.NETWORK)
    val status2: Status = Status.OK(listOf("Data1", "Data2"))

    handleStatus(status1)
    // Network issue
    handleStatus(status2)
    // Data received: [Data1, Data2]
}
参考解决方案 {...}
kotlin
sealed class Status {
    data object Loading : Status()
    data class Error(val problem: Problem) : Status() {
        enum class Problem {
            NETWORK,
            TIMEOUT,
            UNKNOWN
        }
    }

    data class OK(val data: List<String>) : Status()
}

fun handleStatus(status: Status) {
    when (status) {
        is Status.Loading -> println("Loading...")
        is Status.OK -> println("Data received: ${status.data}")
        is Status.Error -> when (status.problem) {
            Status.Error.Problem.NETWORK -> println("Network issue")
            Status.Error.Problem.TIMEOUT -> println("Request timed out")
            Status.Error.Problem.UNKNOWN -> println("Unknown error occurred")
        }
    }
}

fun main() {
    val status1: Status = Status.Error(Status.Error.Problem.NETWORK)
    val status2: Status = Status.OK(listOf("Data1", "Data2"))

    handleStatus(status1)
    // Network issue
    handleStatus(status2)
    // Data received: [Data1, Data2]
}