Kādus dizaina modeļus var izmantot Kotlin valodā…

Bieži tiek izmanto šādus modeļus Kotlin:

Singleton: Ērti realizēt ar object.

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

Factory Method: Izmanto abstraktu funkciju superklasē vai saskarnē, ko realizē apakšklases objektu izveidei.

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: Fāžu grupa, kas izveido saistītas objektu ģimenes.

interface AbstractProductA {
    fun usefulFunctionA()
}

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

interface AbstractFactory {
    fun createProductA(): AbstractProductA
    fun createProductB(): AbstractProductB
}
// Konkrētas realizācijas...

Builder: Vienkāršo sarežģītu objektu veidošanu pa soļiem.

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()
    // ... izmanto picu
}

Adapter: ļauj nesaderīgiem interfeisiem sadarboties.

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

interface Target {
    fun operation()
}

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

Decorator: pievieno jaunas funkcijas esošiem objektiem bez to struktūras maiņas. Kotlin paplašinājumi un delegācija ļoti palīdz šajā.

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

class FileDataSource(private val filename: String) : DataSource {
    override fun readData(): String {
        // Lasīt no faila
        return ""
    }

    override fun writeData(data: String) {
        // Rakstīt uz faila
    }
}

class EncryptionDecorator(private val source: DataSource) : DataSource by source {
    override fun readData(): String {
        // Šifrēt datus
        val data = source.readData()
        return data // šifrētie dati
    }

    override fun writeData(data: String) {
        // Atšifrēt datus
        source.writeData(data) // šifrētie dati
    }
}

Observer: Nosaka "viens pret daudz" atkarību. Coroutines Flow un Kotlin delegētās īpašības var tikt izmantotas.

// Vienkārša realizācija bez Flow
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: Definē ģimeni algoritmu, to inkapsulē un ļauj mainīt to izmantošanu.

interface PaymentStrategy {
    fun pay(amount: Double)
}

class PayByCreditCard(private val cardNumber: String) : PaymentStrategy {
    override fun pay(amount: Double) {
        println("Maksājot $amount, izmantojot kredītkarti $cardNumber")
    }
}

class PayByPayPal(private val email: String) : PaymentStrategy {
    override fun pay(amount: Double) {
        println("Maksājot $amount, izmantojot PayPal $email")
    }
}

class Order(private val paymentStrategy: PaymentStrategy) {
    fun processOrder(amount: Double) {
        // ... dažādi pasūtījuma procesi
        paymentStrategy.pay(amount)
    }
}

State: ļauj objektam mainīt savu uzvedību atkarībā no iekšējā stāvokļa. Sealed klases un when izteiksmes to vienkāršo.

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("Notiek notikuma apstrāde Idle stāvoklī")
                state = State.Loading
            }
            State.Loading -> {
                println("Notiek notikuma apstrāde Loading stāvoklī, ignorēju")
            }
            is State.Error -> {
                println("Notiek notikuma apstrāde Error stāvoklī: ${state.message}")
                // Varbūt pāriet citā stāvoklī
            }
            is State.Success -> {
                println("Notiek notikuma apstrāde Success stāvoklī: ${state.data}")
                // Varbūt pāriet citā stāvoklī
            }
        }
    }
}

Repository: Abstrakcionē piekļuvi datiem no biznesa loģikas.

Daudzi citi modeļi, piemēram, Facade, Proxy, Command, Iterator, Template Method un Visitor, arī ir piemērojami Kotlin. Kotlin valodas īpašības, piemēram, paplašinājumi, delegēšana, data klases un sealed klases, bieži padara modeļu realizāciju idiomātiskāku un kodolīgāku.

Kādus dizaina modeļus var izmantot Kotlin valodā?