Kotlin dilinde hangi tasarım desenleri…

Kotlin'de sıklıkla aşağıdaki tasarım kalıpları kullanılır:

Singleton: object kullanılarak kolayca uygulanır.

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

Factory Method: Üst sınıf veya arayüzde soyut bir fonksiyon kullanılır ve alt sınıflar nesne oluşturmak için bunu uygular.

interface Urun {
    fun operasyon()
}

class SomutUrunA : Urun {
    override fun operasyon() {
        // ...
    }
}

abstract class Yaratici {
    abstract fun fabrikaMetodu(): Urun

    fun baskaBirIslem(): Urun {
        val urun = fabrikaMetodu()
        // ...
        return urun
    }
}

class SomutYaraticiA : Yaratici() {
    override fun fabrikaMetodu(): Urun {
        return SomutUrunA()
    }
}

Abstract Factory: Birbirine bağlı nesne aileleri oluşturmak için kullanılan fabrika grupları.

interface SoyutUrunA {
    fun kullanisliFonksiyonA()
}

interface SoyutUrunB {
    fun kullanisliFonksiyonB()
    fun baskaKullanilisliFonksiyonB(isbirlikci: SoyutUrunA)
}

interface SoyutFabrika {
    fun urunAUret(): SoyutUrunA
    fun urunBUret(): SoyutUrunB
}

// Ürünlerin ve fabrikaların somut uygulamaları...

Builder: Karmaşık nesnelerin adım adım oluşturulmasını kolaylaştırır.

class Pizza private constructor(
    val hamur: String,
    val sos: String?,
    val malzemeler: List<String>
) {
    data class Builder(
        var hamur: String = "ince",
        var sos: String? = null,
        val malzemeler: MutableList<String> = mutableListOf()
    ) {
        fun inceHamur(hamur: String) = apply { this.hamur = hamur }
        fun sosEkle(sos: String) = apply { this.sos = sos }
        fun malzemeEkle(malzeme: String) = apply { this.malzemeler.add(malzeme) }
        fun build() = Pizza(hamur, sos, malzemeler)
    }
}

fun main() {
    val pizza = Pizza.Builder()
        .inceHamur("kalın")
        .sosEkle("domates")
        .malzemeEkle("sucuk")
        .malzemeEkle("mantar")
        .build()
    // ... pizza kullan
}

Adapter: Uygun olmayan arayüzlere sahip nesnelerin birlikte çalışmasını sağlar.

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

interface Target {
    fun operation()
}

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

Decorator: Mevcut nesnelere yeni fonksiyonlar ekler, yapılarını değiştirmez. Kotlin'deki genişletmeler ve delegasyon bunu çok kolaylaştırır.

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

class FileDataSource(private val dosyaAdi: String) : DataSource {
    override fun readData(): String {
        // Dosyadan okuma
        return ""
    }

    override fun writeData(data: String) {
        // Dosyaya yazma
    }
}

class EncryptionDecorator(private val source: DataSource) : DataSource by source {
    override fun readData(): String {
        // Veriyi çöz
        val data = source.readData()
        return data // çözülen veri
    }

    override fun writeData(data: String) {
        // Veriyi şifrele
        source.writeData(data) // şifrelenmiş veri
    }
}

Observer: "birden çoğa" bağımlılığı tanımlar. Kotlin'in coroutines Flow'u ve delegated properties kullanılarak uygulanabilir.

// Flow olmadan basit uygulama
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: Bir algoritma ailesini tanımlar, her birini kapsüller ve birbirleriyle değiştirilebilir hale getirir.

interface PaymentStrategy {
    fun pay(amount: Double)
}

class PayByCreditCard(private val cardNumber: String) : PaymentStrategy {
    override fun pay(amount: Double) {
        println("$amount öde Credit Card $cardNumber kullanarak")
    }
}

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

class Order(private val paymentStrategy: PaymentStrategy) {
    fun processOrder(amount: Double) {
        // ... sipariş işlemi
        paymentStrategy.pay(amount)
    }
}

State: Bir nesnenin davranışını iç duruma bağlı olarak değiştirmesine izin verir. Sealed sınıflar ve when ifadeleri bunu kolaylaştırır.

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 durumunda olay işleme")
                state = State.Loading
            }
            State.Loading -> {
                println("Loading durumunda olay işleme, atlanıyor")
            }
            is State.Error -> {
                println("Hata durumunda olay işleme: ${state.message}")
                // Başka bir duruma geçiş olabilir
            }
            is State.Success -> {
                println("Başarı durumunda olay işleme: ${state.data}")
                // Başka bir duruma geçiş olabilir
            }
        }
    }
}

Kotlin dilinde hangi tasarım desenleri kullanılabilir?