Kokius projektavimo modelius galima naudoti Kotlin…

Dažnai naudojami šie modeliai Kotlin:

Singleton: Patogiai įgyvendinamas naudojant object.

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

Factory Method: Naudojama abstrakti funkcija superklase ar sąsajoje, kurią įgyvendina pogrupiai objektų kūrimui.

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: Fekalų grupė, skirta kurti susijusius objektų šeimas.

interface AbstractProductA {
    fun usefulFunctionA()
}

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

interface AbstractFactory {
    fun createProductA(): AbstractProductA
    fun createProductB(): AbstractProductB
}
// Konkrečios įgyvendinimai...

Builder: Supaprastina sudėtingų objektų kūrimą etapais.

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()
    // ... naudoti pica
}

Adapter: Leidžia nesuderinamiems sąsajų objektams dirbti kartu.

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

interface Target {
    fun operation()
}

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

Decorator: Prideda naujų funkcijų prie esamų objektų jų keisti nereikia. Kotlin plėtiniai ir delegavimas labai padeda.

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

class FileDataSource(private val filename: String) : DataSource {
    override fun readData(): String {
        // Skaityti iš failo
        return ""
    }

    override fun writeData(data: String) {
        // Rašyti į failą
    }
}

class EncryptionDecorator(private val source: DataSource) : DataSource by source {
    override fun readData(): String {
        // Iššifruoti duomenis
        val data = source.readData()
        return data // iššifruoti duomenys
    }

    override fun writeData(data: String) {
        // Užšifruoti duomenis
        source.writeData(data) // užšifruoti duomenys
    }
}

Observer: Apibrėžia "vienas su daug" priklausomybę. Coroutines Flow ir Kotlin deleguoti savybės gali būti naudojamos.

// Paprasta realizacija be 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: Apibrėžia algoritmų šeimą, juos įkapsuliuoja ir leidžia keisti jų naudojimą.

interface PaymentStrategy {
    fun pay(amount: Double)
}

class PayByCreditCard(private val cardNumber: String) : PaymentStrategy {
    override fun pay(amount: Double) {
        println("Mokėjimas $amount naudojant kreditinę kortelę $cardNumber")
    }
}

class PayByPayPal(private val email: String) : PaymentStrategy {
    override fun pay(amount: Double) {
        println("Mokėjimas $amount naudojant PayPal $email")
    }
}

class Order(private val paymentStrategy: PaymentStrategy) {
    fun processOrder(amount: Double) {
        // ... kai kurie užsakymo procesai
        paymentStrategy.pay(amount)
    }
}

State: Leidžia objektui keisti savo elgesį priklausomai nuo vidinės būsenos. Sealed klasės ir when išraiškos tai palengvina.

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("Tvarkau įvykį Idle būsenoje")
                state = State.Loading
            }
            State.Loading -> {
                println("Tvarkau įvykį Loading būsenoje, ignoruoju")
            }
            is State.Error -> {
                println("Tvarkau įvykį Error būsenoje: ${state.message}")
                // Galbūt pereiti į kitą būseną
            }
            is State.Success -> {
                println("Tvarkau įvykį Success būsenoje: ${state.data}")
                // Galbūt pereiti į kitą būseną
            }
        }
    }
}

Repository: Abstrakcionuoja duomenų prieigos logiką nuo verslo logikos.

Daugiau modelių, tokių kaip Facade, Proxy, Command, Iterator, Template Method ir Visitor, taip pat taikomi Kotlin. Kotlin kalbos ypatybės, tokios kaip išplėtimo funkcijos, delegavimas, duomenų klasės ir sealed klasės, dažnai daro modelių įgyvendinimą idiomatiškesnį ir glaustesnį.

Kokius projektavimo modelius galima naudoti Kotlin kalboje?