Kotlin tilida qaysi dizayn shablonlari ishlatilishi…

Kotlinda quyidagi naqshlar ko‘pincha qo‘llaniladi:

Singleton: object orqali qulay amalga oshiriladi.

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

Factory Method: Superklass yoki interfeysda abstrakt funktsiya ishlatiladi, uni subklasslar ob'ektlarni yaratish uchun amalga oshiradi.

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: Bog‘liq ob'ektlar oilaviyatlarini yaratish uchun fabrikalar guruhidir.

interface AbstractProductA {
    fun usefulFunctionA()
}

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

interface AbstractFactory {
    fun createProductA(): AbstractProductA
    fun createProductB(): AbstractProductB
}
// Mahalliy mahsulotlar va fabrikalar uchun aniq amalga oshirishlar...

Builder: Murakkab ob'ektlarni bosqichma-bosqich yaratishni soddalashtiradi.

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

Adapter: Mos kelmaydigan interfeysga ega ob'ektlarni birga ishlash imkonini beradi.

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

interface Target {
    fun operation()
}

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

Decorator: Mavjud ob'ektlarga yangi funksiyalar qo‘shadi, ularning tuzilishini o‘zgartirmasdan. Kotlin kengaytmalar va delegatsiya bu ishni juda osonlashtiradi.

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

class FileDataSource(private val filename: String) : DataSource {
    override fun readData(): String {
        // Fayldan o‘qish
        return ""
    }

    override fun writeData(data: String) {
        // Faylga yozish
    }
}

class EncryptionDecorator(private val source: DataSource) : DataSource by source {
    override fun readData(): String {
        // Ma'lumotlarni shifrlash
        val data = source.readData()
        return data // shifrlangan ma'lumot
    }

    override fun writeData(data: String) {
        // Ma'lumotlarni deshifrlash
        source.writeData(data) // shifrlangan ma'lumot
    }
}

Observer: "birga ko‘p" bog‘liqlikni aniqlaydi. Kotlinning korutinlar Flow va delegatsiya qilingan xususiyatlari bu uchun ishlatilishi mumkin.

// Flow bilan oddiy amalga oshirish
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: Algoritmlarning oilasini belgilaydi, har birini kapsaydi va ularni almashtirishga imkon beradi.

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‘zgartirish imkonini 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.

Kotlin tilida qaysi dizayn shablonlari ishlatilishi mumkin?