Open 类与特殊类
在本章中,你将学习 open 类、它们如何与接口协同工作,以及 Kotlin 中提供的其他特殊类型的类。
Open 类
如果无法使用接口或抽象类,你可以通过将类声明为 open,显式使其可被继承。 为此,请在类声明前使用 open 关键字:
open class Vehicle(val make: String, val model: String)要创建继承自另一个类的类,请在类头后添加一个冒号,后接要继承的父类构造函数的调用。在此示例中,Car 类继承自 Vehicle 类:
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 关键字:
open fun displayInfo() {}若要重写继承的成员函数,请在子类中的函数声明前使用 override 关键字:
override fun displayInfo() {}例如:
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 的属性,想要稍后重写它。重写属性的语法与重写成员函数完全相同。你可以这样做:
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 子类时声明其值:
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 类与接口
你可以创建一个既继承类又实现多个接口的类。在这种情况下,必须在冒号后首先声明父类,然后再列出接口:
// 定义接口
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 关键字:
sealed class Mammal密封类在与 when 表达式结合使用时特别有用。通过使用 when 表达式,你可以为所有可能的子类定义行为。例如:
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 关键字:
enum class State假设你想要创建一个包含流程不同状态的枚举类。每个枚举常量必须用逗号 , 分隔:
enum class State {
IDLE, RUNNING, FINISHED
}State 枚举类包含以下枚举常量:IDLE、RUNNING 和 FINISHED。要访问枚举常量,请使用类名后跟 . 以及枚举常量的名称:
val state = State.RUNNING你可以将此枚举类与 when 表达式结合使用,根据枚举常量的值来定义要执行的操作:
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 值。 在创建枚举常量时,必须使用该属性对其进行初始化:
enum class Color(val rgb: Int) {
RED(0xFF0000),
GREEN(0x00FF00),
BLUE(0x0000FF),
YELLOW(0xFFFF00)
}Kotlin 将十六进制数存储为整数,因此 rgb 属性的类型为 Int,而不是 String。
要向此类添加成员函数,请使用分号 ; 将其与枚举常量分隔开:
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 注解:
@JvmInline
value class Email@JvmInline 注解指示 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() 函数中的代码能够成功运行:
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.
}参考解决方案 {...}
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),补全以下代码。
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]
}参考解决方案 {...}
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]
}