Milliseid disainimustreid saab Kotlin keeles…

Kotlinis sageli kasutatakse järgmisi mustreid:

Singleton: Mugav rakendada object kaudu.

object MySingleton {
    fun doSomething() {
        // ...
    }
}

Factory Method: Kasutatakse abstraktset funktsiooni superklassis või liideses, mida rakendavad alamklassid objektide loomiseks.

interface Product {
    fun operation()
}

class ConcreteProductA : Product {
    override fun operation() {
        // ...
    }
}

abstract class Creator {
    abstract fun factoryMethod(): Product

    fun someOperation(): Product {
        val product = factoryMethod()
        // ...
        return product
    }
}

class ConcreteCreatorA : Creator() {
    override fun factoryMethod(): Product {
        return ConcreteProductA()
    }
}

Abstract Factory: Tööriistade grupp, mis loob seotud objektide perekondi.

interface AbstractProductA {
    fun usefulFunctionA()
}

interface AbstractProductB {
    fun usefulFunctionB()
    fun anotherUsefulFunctionB(collaborator: AbstractProductA)
}

interface AbstractFactory {
    fun createProductA(): AbstractProductA
    fun createProductB(): AbstractProductB
}
// Konkreetsed rakendused...

Builder: Lihtsustab keeruliste objektide loomist samm-sammult.

class Pizza private constructor(
    val crust: String,
    val sauce: String?,
    val toppings: List<String>
) {
    data class Builder(
        var crust: String = "thin",
        var sauce: String? = null,
        val toppings: MutableList<String> = mutableListOf()
    ) {
        fun withCrust(crust: String) = apply { this.crust = crust }
        fun withSauce(sauce: String) = apply { this.sauce = sauce }
        fun addTopping(topping: String) = apply { this.toppings.add(topping) }
        fun build() = Pizza(crust, sauce, toppings)
    }
}

fun main() {
    val pizza = Pizza.Builder()
        .withCrust("thick")
        .withSauce("tomato")
        .addTopping("pepperoni")
        .addTopping("mushrooms")
        .build()
    // ... kasu pitsa
}

Adapter: võimaldab mittevastavate liideste ühildumist.

open class Adaptee {
    fun specificOperation() {
        // ...
    }
}

interface Target {
    fun operation()
}

class Adapter(private val adaptee: Adaptee) : Target {
    override fun operation() {
        adaptee.specificOperation()
    }
}

Decorator: lisab olemasolevatele objektidele uusi funktsioone ilma nende struktuuri muutmata. Kotlin'i laiendused ja delegatsioon aitavad selles.

interface DataSource {
    fun readData(): String
    fun writeData(data: String)
}

class FileDataSource(private val filename: String) : DataSource {
    override fun readData(): String {
        // Failist lugemine
        return ""
    }

    override fun writeData(data: String) {
        // Faili kirjutamine
    }
}

class EncryptionDecorator(private val source: DataSource) : DataSource by source {
    override fun readData(): String {
        // Krüpteerimata andmete dekrüpteerimine
        val data = source.readData()
        return data // dekrüpteeritud andmed
    }

    override fun writeData(data: String) {
        // Krüpteerimine
        source.writeData(data) // krüpteeritud andmed
    }
}

Observer: määratleb "üks mitme" sõltuvuse. Coroutines Flow ja Kotlin'i delegeeritud omadused võivad olla kasutusel.

// Lihtne rakendus ilma Flow-ta
interface Observer {
    fun update(message: String)
}

class Subject {
    private val observers = mutableListOf<Observer>()

    fun attach(observer: Observer) {
        observers.add(observer)
    }

    fun detach(observer: Observer) {
        observers.remove(observer)
    }

    fun notifyObservers(message: String) {
        observers.forEach { it.update(message) }
    }
}

Strategy: Määratleb algoritmide perekonna, inkapsuleerib igaühe ja muudab nende kasutamise vahetatavaks.

interface PaymentStrategy {
    fun pay(amount: Double)
}

class PayByCreditCard(private val cardNumber: String) : PaymentStrategy {
    override fun pay(amount: Double) {
        println("Maksed $amount kasutades krediitkaarti $cardNumber")
    }
}

class PayByPayPal(private val email: String) : PaymentStrategy {
    override fun pay(amount: Double) {
        println("Maksed $amount kasutades PayPal $email")
    }
}

class Order(private val paymentStrategy: PaymentStrategy) {
    fun processOrder(amount: Double) {
        // ... mõni tellimuse töötlemine
        paymentStrategy.pay(amount)
    }
}

State: võimaldab objektil muuta oma käitumist sõltuvalt sisemisest olekust. Sealed klassid ja when väljendid seda lihtsustavad.

sealed class State {
    object Idle : State()
    object Loading : State()
    data class Error(val message: String) : State()
    data class Success(val data: Any) : State()
}

class Context {
    var state: State = State.Idle

    fun handleEvent() {
        when (state) {
            State.Idle -> {
                println("Käsitlen Idle olekus sündmust")
                state = State.Loading
            }
            State.Loading -> {
                println("Käsitlen Loading olekus sündmust, ignoreerin")
            }
            is State.Error -> {
                println("Käsitlen Error olekus: ${state.message}")
                // Võib-olla liikumine teise olekusse
            }
            is State.Success -> {
                println("Käsitlen Success olekus: ${state.data}")
                // Võib-olla liikumine teise olekusse
            }
        }
    }
}

Repository: abstraktsioon andmejuurdepääsust äriloogikast.

Paljud teised mustrid, nagu Facade, Proxy, Command, Iterator, Template Method ja Visitor, on samuti rakendatavad Kotlinis. Kotlin'i keeleomadused, nagu laiendused, delegatsioon, data klassid ja sealed klassid, muudavad mustrite rakendamise sageli idiomaatilisemaks ja lühemaks.

Milliseid disainimustreid saab Kotlin keeles kasutada?