Welke ontwerppatronen kunnen worden gebruikt in de…

In Kotlin worden vaak de volgende patronen toegepast:

Singleton: Handig geïmplementeerd via object.

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

Factory Method: Gebruikt een abstracte functie in een superklasse of interface, die door subklassen wordt geïmplementeerd om objecten te maken.

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: Een groep fabrieken voor het maken van gerelateerde families van objecten.

interface AbstractProductA {
    fun usefulFunctionA()
}

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

interface AbstractFactory {
    fun createProductA(): AbstractProductA
    fun createProductB(): AbstractProductB
}
// Concrete implementaties van producten en fabrieken...

Builder: Vereenvoudigt het stapsgewijs maken van complexe objecten.

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()
    // ... gebruik pizza
}

Adapter: Maakt het mogelijk dat objecten met incompatibele interfaces samen kunnen werken.

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

interface Target {
    fun operation()
}

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

Decorator: Voegt nieuwe functies toe aan bestaande objecten zonder hun structuur te wijzigen. Kotlin extensies en delegatie maken dit heel eenvoudig.

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

class FileDataSource(private val filename: String) : DataSource {
    override fun readData(): String {
        // Lezen uit bestand
        return ""
    }

    override fun writeData(data: String) {
        // Schrijven naar bestand
    }
}

class EncryptionDecorator(private val source: DataSource) : DataSource by source {
    override fun readData(): String {
        // Data ontsleutelen
        val data = source.readData()
        return data // ontsleutelde data
    }

    override fun writeData(data: String) {
        // Data versleutelen
        source.writeData(data) // versleutelde data
    }
}

Observer: Definieert een "een-op-veel" afhankelijkheid. Kotlin's coroutines Flow en delegated properties kunnen hiervoor worden gebruikt.

// Eenvoudige implementatie zonder 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: Definieert een familie algoritmen, kapselt elk ervan in en maakt ze uitwisselbaar.

interface PaymentStrategy {
    fun pay(amount: Double)
}

class PayByCreditCard(private val cardNumber: String) : PaymentStrategy {
    override fun pay(amount: Double) {
        println("$amount to‘lash uchun Kredit karta $cardNumber")
    }
}

class PayByPayPal(private val email: String) : PaymentStrategy {
    override fun pay(amount: Double) {
        println("$amount to‘lash uchun PayPal $email")
    }
}

class Order(private val paymentStrategy: PaymentStrategy) {
    fun processOrder(amount: Double) {
        // ... buyurtma ishlov berish
        paymentStrategy.pay(amount)
    }
}

State: Ob'ektning xatti-harakatini ichki holatga qarab o‘zgartirishga imkon beradi. Sealed klasslar va when ifodalarini soddalashtiradi.

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("Idle holatida voqeani boshqarish")
                state = State.Loading
            }
            State.Loading -> {
                println("Loading holatida voqeani boshqarish, e'tiborsiz")
            }
            is State.Error -> {
                println("Error holatida voqeani boshqarish: ${state.message}")
                // Ehtimol, boshqa holatga o'tish
            }
            is State.Success -> {
                println("Success holatida voqeani boshqarish: ${state.data}")
                // Ehtimol, boshqa holatga o'tish
            }
        }
    }
}

Repository: Biznes logikadan ma'lumotlarga kirish logikasini ajratib turadi.

Kotlinda Facade, Proxy, Command, Iterator, Template Method va Visitor kabi ko‘plab boshqa naqshlar ham qo‘llaniladi. Kotlinning til xususiyatlari, masalan, kengaytmalar, delegatsiya, data klasslar va sealed klasslar, naqshlarni amalga oshirishni ko‘pincha idiomatika va qisqaroq qiladi.

Welke ontwerppatronen kunnen worden gebruikt in de Kotlin-taal?