Классы и интерфейсы

Наследование классов

В предыдущей главе мы рассмотрели, как можно использовать функции-расширения, чтобы расширять классы, не изменяя исходный код. Но что, если вы работаете над чем-то сложным и было бы полезно совместно использовать код между классами? В таких случаях можно использовать наследование классов.

По умолчанию от классов в Kotlin нельзя наследоваться. Kotlin устроен таким образом, чтобы предотвратить непреднамеренное наследование и упростить обслуживание ваших классов.

В Kotlin поддерживается только одиночное наследование: наследоваться можно только от одного класса за раз. Этот класс называется родительским.

Родительский класс может наследоваться от другого класса (класса-прародителя), образуя иерархию. На вершине иерархии классов Kotlin находится общий родительский класс: Any. В конечном итоге все классы наследуются от класса Any:

Класс Any автоматически предоставляет функцию toString() в качестве функции-члена. Поэтому вы можете использовать эту унаследованную функцию в любом из своих классов. Например:

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

fun main() {
    //sampleStart
    val car1 = Car("Toyota", "Corolla", 4)

    // Uses the .toString() function via string templates to print class properties
    println("Car1: make=${car1.make}, model=${car1.model}, numberOfDoors=${car1.numberOfDoors}")
    // Car1: make=Toyota, model=Corolla, numberOfDoors=4
    //sampleEnd
}

Если вы хотите использовать наследование для совместного использования кода между классами, сначала рассмотрите возможность применения абстрактных классов.

abstract class Animal

abstract fun makeSound()
abstract val sound: String

abstract class Product(val name: String, var price: Double) {
    // Abstract property for the product category
    abstract val category: String

    // A function that can be shared by all products
    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"
}

abstract class Product(val name: String, var price: Double) {
    // Abstract property for the product category
    abstract val category: String

    // A function that can be shared by all products
    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"
}

//sampleStart
fun main() {
    // Creates an instance of the Electronic class
    val laptop = Electronic(name = "Laptop", price = 1000.0, warranty = 2)

    println(laptop.productInfo())
    // Product: Laptop, Category: Electronic, Price: 1000.0
}
//sampleEnd

Интерфейсы

Интерфейсы похожи на классы, но имеют несколько отличий:

• Нельзя создать экземпляр интерфейса. У интерфейсов нет конструктора или заголовка.

• Их функции и свойства по умолчанию неявно доступны для наследования. В Kotlin говорят, что они «открытые».

• Не нужно помечать функции ключевым словом abstract, если вы не предоставляете для них реализацию.

Как и абстрактные классы, интерфейсы используются для определения набора функций и свойств, которые классы могут унаследовать и реализовать позднее. Такой подход помогает сосредоточиться на абстракции, описанной интерфейсом, а не на деталях конкретной реализации. Использование интерфейсов делает код:

• Более модульным, поскольку разные части изолированы и могут развиваться независимо друг от друга.

• Более понятным благодаря объединению связанных функций в целостный набор.

• Более простым для тестирования, поскольку реализацию можно быстро заменить заглушкой.

Чтобы объявить интерфейс, используйте ключевое слово interface:

interface PaymentMethod

class CreditCardPayment : PaymentMethod

interface PaymentMethod {
    // Functions are inheritable by default
    fun initiatePayment(amount: Double): String
}

class CreditCardPayment(val cardNumber: String, val cardHolderName: String, val expiryDate: String) : PaymentMethod {
    override fun initiatePayment(amount: Double): String {
        // Simulate processing payment with credit card
        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.
}

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 {
        // Simulate processing payment with credit card
        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
}

Делегирование

Интерфейсы полезны, но если интерфейс содержит много функций, в дочерних классах может оказаться много шаблонного кода. Если вы хотите переопределить лишь небольшую часть поведения класса, вам придётся многократно повторять один и тот же код.

Например, предположим, что у вас есть интерфейс 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)"
    }
}
//sampleStart
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()
    }
}
//sampleEnd
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)"
    }
}

//sampleStart
class CanvasSession(val tool: DrawingTool) : DrawingTool by tool {
    // No boilerplate code!
    override val color: String = "blue"
}
//sampleEnd
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, но теперь не нужно добавлять новые строки кода для каждой унаследованной функции-члена.

Подробнее см. в разделе Делегирование.

Практика

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.
}

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 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 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!
}