類別與介面
在入門導覽中,你學習了如何使用類別與資料類別來儲存資料,並維護可在程式碼中共享的特性集合。最終,你會希望建立階層結構,以便在專案中有效率地共享程式碼。本章將說明 Kotlin 為共享程式碼所提供的選項,以及它們如何讓你的程式碼更安全且更易於維護。
類別繼承
在前面的章節中,我們介紹了如何使用擴充函式來擴充類別,而無需修改原始程式碼。但如果你正在處理較複雜的情況,且在類別之間共享程式碼會很有幫助時,該怎麼辦?在這種情況下,你可以使用類別繼承。
預設情況下,Kotlin 中的類別無法被繼承。Kotlin 採用這種設計是為了防止非預期的繼承,並讓你的類別更容易維護。
Kotlin 類別僅支援單一繼承,這意味著一次只能繼承一個類別。這個類別被稱為父類別。
一個類別的父類別又繼承自另一個類別(祖父類別),從而形成階層結構。在 Kotlin 類別階層結構的頂端是共同的父類別:Any。所有類別最終都繼承自 Any 類別:

Any 類別會自動提供 toString() 函式作為成員函式。因此,你可以在任何類別中使用這個繼承而來的函式。例如:
class Car(val make: String, val model: String, val numberOfDoors: Int)
fun main() {
val car1 = Car("Toyota", "Corolla", 4)
// 透過字串範本使用 .toString() 函式來印出類別屬性
println("Car1: make=${car1.make}, model=${car1.model}, numberOfDoors=${car1.numberOfDoors}")
// Car1: make=Toyota, model=Corolla, numberOfDoors=4
}如果你想使用繼承在類別之間共享某些程式碼,請先考慮使用抽象類別。
抽象類別
抽象類別預設可以被繼承。抽象類別的目的是提供供其他類別繼承或實作的成員。因此,它們擁有建構函式,但你無法從中建立執行個體。在子類別中,你可以使用 override 關鍵字來定義父類別屬性與函式的行為。透過這種方式,你可以說子類別「覆寫」了父類別的成員。
當你定義繼承函式或屬性的行為時,我們稱之為實作。
抽象類別既可以包含帶有實作的函式與屬性,也可以包含沒有實作的函式與屬性(稱為抽象函式與抽象屬性)。
若要建立抽象類別,請使用 abstract 關鍵字:
abstract class Animal若要宣告沒有實作的函式或屬性,也是使用 abstract 關鍵字:
abstract fun makeSound()
abstract val sound: String例如,假設你想建立一個名為 Product 的抽象類別,以便從中建立子類別來定義不同的產品類別:
abstract class Product(val name: String, var price: Double) {
// 產品類別的抽象屬性
abstract val category: String
// 所有產品都可以共享的函式
fun productInfo(): String {
return "Product: $name, Category: $category, Price: $price"
}
}在此抽象類別中:
- 建構函式有兩個代表產品
name和price的參數。 - 有一個抽象屬性,以字串形式包含產品類別。
- 有一個印出產品資訊的函式。
讓我們為電子產品建立一個子類別。在子類別中為 category 屬性定義實作之前,你必須使用 override 關鍵字:
class Electronic(name: String, price: Double, val warranty: Int) : Product(name, price) {
override val category = "Electronic"
}Electronic 類別:
- 繼承自
Product抽象類別。 - 在建構函式中有一個額外的參數:
warranty,這是電子產品特有的。 - 覆寫
category屬性使其包含字串"Electronic"。
現在,你可以像這樣使用這些類別:
abstract class Product(val name: String, var price: Double) {
// 產品類別的抽象屬性
abstract val category: String
// 所有產品都可以共享的函式
fun productInfo(): String {
return "Product: $name, Category: $category, Price: $price"
}
}
class Electronic(name: String, price: Double, val warranty: Int) : Product(name, price) {
override val category = "Electronic"
}
fun main() {
// 建立 Electronic 類別的執行個體
val laptop = Electronic(name = "Laptop", price = 1000.0, warranty = 2)
println(laptop.productInfo())
// Product: Laptop, Category: Electronic, Price: 1000.0
}雖然抽象類別非常適合以這種方式共享程式碼,但它們受到限制,因為 Kotlin 中的類別僅支援單一繼承。如果你需要從多個來源繼承,請考慮使用介面。
介面
介面與類別相似,但它們有一些差異:
- 你無法建立介面的執行個體。它們沒有建構函式或標頭。
- 它們的函式與屬性預設為隱式可繼承。在 Kotlin 中,我們稱之為「open」。
- 如果你沒有為函式提供實作,則不需要將其標記為
abstract。
與抽象類別類似,你可以使用介面來定義一組函式與屬性,供類別後續繼承與實作。這種方法有助於你專注於介面所描述的抽象概念,而非具體的實作細節。使用介面可讓你的程式碼:
- 更模組化,因為它隔離了不同部分,使它們能夠獨立演進。
- 更易於理解,將相關的函式組織成一個具凝聚力的集合。
- 更易於測試,因為你可以快速將實作替換為 Mock 以進行測試。
若要宣告介面,請使用 interface 關鍵字:
interface PaymentMethod介面實作
介面支援多重繼承,因此一個類別可以同時實作多個介面。首先,讓我們看看一個類別實作一個介面的情境。
若要建立實作介面的類別,請在類別標頭後方加上冒號,接著加上你想實作的介面名稱。介面名稱後不需要加上圓括號 (),因為介面沒有建構函式:
class CreditCardPayment : PaymentMethod例如:
interface PaymentMethod {
// 函式預設可繼承
fun initiatePayment(amount: Double): String
}
class CreditCardPayment(val cardNumber: String, val cardHolderName: String, val expiryDate: String) : PaymentMethod {
override fun initiatePayment(amount: Double): String {
// 模擬使用信用卡處理付款
return "Payment of $$amount initiated using Credit Card ending in ${cardNumber.takeLast(4)}."
}
}
fun main() {
val paymentMethod = CreditCardPayment("1234 5678 9012 3456", "John Doe", "12/25")
println(paymentMethod.initiatePayment(100.0))
// Payment of $100.0 initiated using Credit Card ending in 3456.
}在此範例中:
PaymentMethod是一個介面,包含一個沒有實作的initiatePayment()函式。CreditCardPayment是一個實作了PaymentMethod介面的類別。CreditCardPayment類別覆寫了繼承而來的initiatePayment()函式。paymentMethod是CreditCardPayment類別的執行個體。- 在
paymentMethod執行個體上呼叫覆寫後的initiatePayment()函式,並帶入參數100.0。
若要建立實作多個介面的類別,請在類別標頭後加上冒號,接著加上你想實作的介面名稱,並以逗號分隔:
class CreditCardPayment : PaymentMethod, PaymentType例如:
interface PaymentMethod {
fun initiatePayment(amount: Double): String
}
interface PaymentType {
val paymentType: String
}
class CreditCardPayment(val cardNumber: String, val cardHolderName: String, val expiryDate: String) : PaymentMethod,
PaymentType {
override fun initiatePayment(amount: Double): String {
// 模擬使用信用卡處理付款
return "Payment of $$amount initiated using Credit Card ending in ${cardNumber.takeLast(4)}."
}
override val paymentType: String = "Credit Card"
}
fun main() {
val paymentMethod = CreditCardPayment("1234 5678 9012 3456", "John Doe", "12/25")
println(paymentMethod.initiatePayment(100.0))
// Payment of $100.0 initiated using Credit Card ending in 3456.
println("Payment is by ${paymentMethod.paymentType}")
// Payment is by Credit Card
}在此範例中:
PaymentMethod是一個介面,包含一個沒有實作的initiatePayment()函式。PaymentType是一個介面,包含一個未初始化的paymentType屬性。CreditCardPayment是一個實作了PaymentMethod與PaymentType介面的類別。CreditCardPayment類別覆寫了繼承而來的initiatePayment()函式與paymentType屬性。paymentMethod是CreditCardPayment類別的執行個體。- 在
paymentMethod執行個體上呼叫覆寫後的initiatePayment()函式,並帶入參數100.0。 - 在
paymentMethod執行個體上存取覆寫後的paymentType屬性。
如需關於介面與介面繼承的更多資訊,請參閱介面。
委託
介面很有用,但如果你的介面包含許多函式,其子類別最終可能會產生大量樣板程式碼。如果你只想覆寫類別行為的一小部分,你就必須撰寫許多重複的程式碼。
樣板程式碼是指在軟體專案中多個部分重複使用,且幾乎不加修改或完全不修改的一段程式碼。
例如,假設你有一個名為 DrawingTool 的介面,其中包含若干函式以及一個名為 color 的屬性:
interface DrawingTool {
val color: String
fun draw(shape: String)
fun erase(area: String)
fun getToolInfo(): String
}你建立了一個名為 PenTool 的類別,該類別實作了 DrawingTool 介面,並為其所有成員提供了實作:
class PenTool : DrawingTool {
override val color: String = "black"
override fun draw(shape: String) {
println("Drawing $shape using a pen in $color")
}
override fun erase(area: String) {
println("Erasing $area with pen tool")
}
override fun getToolInfo(): String {
return "PenTool(color=$color)"
}
}你想建立一個類似 PenTool 的類別,具備相同的行為但具有不同的 color 值。一種方法是建立一個新類別,該類別接受實作了 DrawingTool 介面的物件作為參數(例如 PenTool 類別的執行個體)。接著,在該類別內部覆寫 color 屬性。
但是在這種情境下,你必須為 DrawingTool 介面的每個成員新增實作:
interface DrawingTool {
val color: String
fun draw(shape: String)
fun erase(area: String)
fun getToolInfo(): String
}
class PenTool : DrawingTool {
override val color: String = "black"
override fun draw(shape: String) {
println("Drawing $shape using a pen in $color")
}
override fun erase(area: String) {
println("Erasing $area with pen tool")
}
override fun getToolInfo(): String {
return "PenTool(color=$color)"
}
}
class CanvasSession(val tool: DrawingTool) : DrawingTool {
override val color: String = "blue"
override fun draw(shape: String) {
tool.draw(shape)
}
override fun erase(area: String) {
tool.erase(area)
}
override fun getToolInfo(): String {
return tool.getToolInfo()
}
}
fun main() {
val pen = PenTool()
val session = CanvasSession(pen)
println("Pen color: ${pen.color}")
// Pen color: black
println("Session color: ${session.color}")
// Session color: blue
session.draw("circle")
// Drawing circle with pen in black
session.erase("top-left corner")
// Erasing top-left corner with pen tool
println(session.getToolInfo())
// PenTool(color=black)
}你可以看到,如果 DrawingTool 介面中包含大量成員函式,CanvasSession 類別中的樣板程式碼數量可能會非常可觀。然而,還有一種替代方案。
在 Kotlin 中,你可以使用 by 關鍵字將介面實作委託給一個類別執行個體。例如:
class CanvasSession(val tool: DrawingTool) : DrawingTool by tool在這裡,tool 是被委託實作成員函式的 PenTool 類別執行個體的名稱。
現在你不需要在 CanvasSession 類別中為成員函式新增實作。編譯器會自動為你從 PenTool 類別中完成此操作。這能讓你免於編寫大量樣板程式碼。相反地,你只需為子類別中想要改變的行為新增程式碼。
例如,如果你想變更 color 屬性的值:
interface DrawingTool {
val color: String
fun draw(shape: String)
fun erase(area: String)
fun getToolInfo(): String
}
class PenTool : DrawingTool {
override val color: String = "black"
override fun draw(shape: String) {
println("Drawing $shape using a pen in $color")
}
override fun erase(area: String) {
println("Erasing $area with pen tool")
}
override fun getToolInfo(): String {
return "PenTool(color=$color)"
}
}
class CanvasSession(val tool: DrawingTool) : DrawingTool by tool {
// No boilerplate code!
override val color: String = "blue"
}
fun main() {
val pen = PenTool()
val session = CanvasSession(pen)
println("Pen color: ${pen.color}")
// Pen color: black
println("Session color: ${session.color}")
// Session color: blue
session.draw("circle")
// Drawing circle with pen in black
session.erase("top-left corner")
// Erasing top-left corner with pen tool
println(session.getToolInfo())
// PenTool(color=black)
}如果你願意,也可以在 CanvasSession 類別中覆寫繼承而來的成員函式的行為,但現在你不需要為每個繼承而來的成員函式都新增程式碼行。
如需更多資訊,請參閱委託。
練習
使用抽象類別實作智慧裝置
想像你正在開發一個智慧家庭系統。智慧家庭通常具有不同類型的裝置,它們都具備某些基本功能,但也有各自獨特的行為。在下方的程式碼範例中,完成名為 SmartDevice 的 abstract 類別,使子類別 SmartLight 能夠成功編譯。
接著,建立另一個名為 SmartThermostat 的子類別,該類別繼承自 SmartDevice 類別,並實作 turnOn() 與 turnOff() 函式,以印出描述哪個溫控器正在加熱或已關閉的陳述式。最後,新增另一個名為 adjustTemperature() 的函式,該函式接受溫度測量值作為輸入,並印出:$name thermostat set to $temperature°C.
提示
SmartDevice 類別中新增 turnOn() 與 turnOff() 函式,以便稍後在 SmartThermostat 類別中覆寫它們的行為。 abstract class // Write your code here
class SmartLight(name: String) : SmartDevice(name) {
override fun turnOn() {
println("$name is now ON.")
}
override fun turnOff() {
println("$name is now OFF.")
}
fun adjustBrightness(level: Int) {
println("Adjusting $name brightness to $level%.")
}
}
class SmartThermostat // Write your code here
fun main() {
val livingRoomLight = SmartLight("Living Room Light")
val bedroomThermostat = SmartThermostat("Bedroom Thermostat")
livingRoomLight.turnOn()
// Living Room Light is now ON.
livingRoomLight.adjustBrightness(10)
// Adjusting Living Room Light brightness to 10%.
livingRoomLight.turnOff()
// Living Room Light is now OFF.
bedroomThermostat.turnOn()
// Bedroom Thermostat thermostat is now heating.
bedroomThermostat.adjustTemperature(5)
// Bedroom Thermostat thermostat set to 5°C.
bedroomThermostat.turnOff()
// Bedroom Thermostat thermostat is now off.
}範例解答 {...}
abstract class SmartDevice(val name: String) {
abstract fun turnOn()
abstract fun turnOff()
}
class SmartLight(name: String) : SmartDevice(name) {
override fun turnOn() {
println("$name is now ON.")
}
override fun turnOff() {
println("$name is now OFF.")
}
fun adjustBrightness(level: Int) {
println("Adjusting $name brightness to $level%.")
}
}
class SmartThermostat(name: String) : SmartDevice(name) {
override fun turnOn() {
println("$name thermostat is now heating.")
}
override fun turnOff() {
println("$name thermostat is now off.")
}
fun adjustTemperature(temperature: Int) {
println("$name thermostat set to $temperature°C.")
}
}
fun main() {
val livingRoomLight = SmartLight("Living Room Light")
val bedroomThermostat = SmartThermostat("Bedroom Thermostat")
livingRoomLight.turnOn()
// Living Room Light is now ON.
livingRoomLight.adjustBrightness(10)
// Adjusting Living Room Light brightness to 10%.
livingRoomLight.turnOff()
// Living Room Light is now OFF.
bedroomThermostat.turnOn()
// Bedroom Thermostat thermostat is now heating.
bedroomThermostat.adjustTemperature(5)
// Bedroom Thermostat thermostat set to 5°C.
bedroomThermostat.turnOff()
// Bedroom Thermostat thermostat is now off.
}實作媒體介面
建立一個名為 Media 的介面,用於實作具體的媒體類別(例如 Audio、Video 或 Podcast)。你的介面必須包含:
- 一個名為
title的屬性,用以表示媒體的標題。 - 一個名為
play()的函式,用以播放媒體。
接著,建立一個實作了 Media 介面的 Audio 類別。Audio 類別必須在其建構函式中使用 title 屬性,並擁有一個名為 composer 且型別為 String 的額外屬性。在該類別中,實作 play() 函式以印出:"Playing audio: $title, composed by $composer"。
提示
override 關鍵字,以在建構函式中實作介面中的屬性。 interface // Write your code here
class // Write your code here
fun main() {
val audio = Audio("Symphony No. 5", "Beethoven")
audio.play()
// Playing audio: Symphony No. 5, composed by Beethoven
}範例解答 {...}
interface Media {
val title: String
fun play()
}
class Audio(override val title: String, val composer: String) : Media {
override fun play() {
println("Playing audio: $title, composed by $composer")
}
}
fun main() {
val audio = Audio("Symphony No. 5", "Beethoven")
audio.play()
// Playing audio: Symphony No. 5, composed by Beethoven
}結合介面與抽象類別
你正在為電子商務應用程式建構付款處理系統。每種付款方式都需要能夠授權付款並處理交易。某些付款方式還需要能夠處理退款。
在
Refundable介面中,新增一個名為refund()的函式以處理退款。在
PaymentMethod抽象類別中:- 新增一個名為
authorize()的函式,該函式接受一個金額並印出包含該金額的訊息。 - 新增一個名為
processPayment()的抽象函式,同樣接受一個金額。
- 新增一個名為
建立一個名為
CreditCard的類別,實作Refundable介面與PaymentMethod抽象類別。在此類別中,為refund()和processPayment()函式新增實作,使它們印出以下陳述式:"Refunding $amount to the credit card.""Processing credit card payment of $amount."
interface Refundable {
// Write your code here
}
abstract class PaymentMethod(val name: String) {
// Write your code here
}
class CreditCard // Write your code here
fun main() {
val visa = CreditCard("Visa")
visa.authorize(100.0)
// Authorizing payment of $100.0.
visa.processPayment(100.0)
// Processing credit card payment of $100.0.
visa.refund(50.0)
// Refunding $50.0 to the credit card.
}範例解答 {...}
interface Refundable {
fun refund(amount: Double)
}
abstract class PaymentMethod(val name: String) {
fun authorize(amount: Double) {
println("Authorizing payment of $$amount.")
}
abstract fun processPayment(amount: Double)
}
class CreditCard(name: String) : PaymentMethod(name), Refundable {
override fun processPayment(amount: Double) {
println("Processing credit card payment of $$amount.")
}
override fun refund(amount: Double) {
println("Refunding $$amount to the credit card.")
}
}
fun main() {
val visa = CreditCard("Visa")
visa.authorize(100.0)
// Authorizing payment of $100.0.
visa.processPayment(100.0)
// Processing credit card payment of $100.0.
visa.refund(50.0)
// Refunding $50.0 to the credit card.
}使用介面委託自訂行為
你有一個具備基本功能的簡易傳訊應用程式,但你希望為「智慧(smart)」訊息新增一些功能,同時不大幅重複你的程式碼。
在下方的程式碼中,定義一個名為 SmartMessenger 的類別,該類別繼承自 Messenger 介面,但將實作委託給 BasicMessenger 類別的執行個體。
在 SmartMessenger 類別中,覆寫 sendMessage() 函式以傳送智慧訊息。該函式必須接受 message 作為輸入,並印出陳述式:"Sending a smart message: $message"。此外,呼叫來自 BasicMessenger 類別的 sendMessage() 函式,並在訊息前加上前綴 [smart]。
你不需要在 SmartMessenger 類別中重寫 receiveMessage() 函式。
interface Messenger {
fun sendMessage(message: String)
fun receiveMessage(): String
}
class BasicMessenger : Messenger {
override fun sendMessage(message: String) {
println("Sending message: $message")
}
override fun receiveMessage(): String {
return "You've got a new message!"
}
}
class SmartMessenger // Write your code here
fun main() {
val basicMessenger = BasicMessenger()
val smartMessenger = SmartMessenger(basicMessenger)
basicMessenger.sendMessage("Hello!")
// Sending message: Hello!
println(smartMessenger.receiveMessage())
// You've got a new message!
smartMessenger.sendMessage("Hello from SmartMessenger!")
// Sending a smart message: Hello from SmartMessenger!
// Sending message: [smart] Hello from SmartMessenger!
}範例解答 {...}
interface Messenger {
fun sendMessage(message: String)
fun receiveMessage(): String
}
class BasicMessenger : Messenger {
override fun sendMessage(message: String) {
println("Sending message: $message")
}
override fun receiveMessage(): String {
return "You've got a new message!"
}
}
class SmartMessenger(val basicMessenger: BasicMessenger) : Messenger by basicMessenger {
override fun sendMessage(message: String) {
println("Sending a smart message: $message")
basicMessenger.sendMessage("[smart] $message")
}
}
fun main() {
val basicMessenger = BasicMessenger()
val smartMessenger = SmartMessenger(basicMessenger)
basicMessenger.sendMessage("Hello!")
// Sending message: Hello!
println(smartMessenger.receiveMessage())
// You've got a new message!
smartMessenger.sendMessage("Hello from SmartMessenger!")
// Sending a smart message: Hello from SmartMessenger!
// Sending message: [smart] Hello from SmartMessenger!
}