Quali pattern di progettazione possono essere…

In Kotlin, the following patterns are often used:

Singleton: Conveniently implemented via object.

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

Factory Method: Uses an abstract function in a superclass or interface, implemented by subclasses to create objects.

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: A group of factories for creating related families of objects.

interface AbstractProductA {
    fun usefulFunctionA()
}

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

interface AbstractFactory {
    fun createProductA(): AbstractProductA
    fun createProductB(): AbstractProductB
}
// Concrete implementations of products and factories...

Builder: Simplifies the creation of complex objects step by step.

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

Adapter: Allows objects with incompatible interfaces to work together.

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

interface Target {
    fun operation()
}

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

Decorator: Adds new functions to existing objects without changing their structure. Kotlin extensions and delegation facilitate this.

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

class FileDataSource(private val filename: String) : DataSource {
    override fun readData(): String {
        // Read from file
        return ""
    }

    override fun writeData(data: String) {
        // Write to file
    }
}

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

    override fun writeData(data: String) {
        // Encrypt data
        source.writeData(data) // encrypted data
    }
}

Observer: Defines a "one-to-many" dependency. Kotlin's coroutines Flow and delegated properties can be used for implementation.

// Simple implementation without 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: Defines a family of algorithms, encapsulates each one, and makes them interchangeable.

interface PaymentStrategy {
    fun pay(amount: Double)
}

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

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

class Order(private val paymentStrategy: PaymentStrategy) {
    fun processOrder(amount: Double) {
        // ... some order processing
        paymentStrategy.pay(amount)
    }
}

State: Allows an object to change its behavior depending on its internal state. Sealed classes and when expressions simplify implementation.

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("Handling event in Idle state")
                state = State.Loading
            }
            State.Loading -> {
                println("Handling event in Loading state, ignoring.")
            }
            is State.Error -> {
                println("Handling event in Error state: ${state.message}")
                // Possibly transition to another state
            }
            is State.Success -> {
                println("Handling event in Success state: ${state.data}")
                // Possibly transition to another state
            }
        }
    }
}

Repository: Abstracts data access logic from business logic.

Many other patterns such as Facade, Proxy, Command, Iterator, Template Method, and Visitor are also applicable in Kotlin. Kotlin's language features like extensions, delegation, data classes, and sealed classes often make pattern implementation more idiomatic and concise.

Quali pattern di progettazione possono essere utilizzati nel linguaggio Kotlin?