Entwurfsmuster in Kotlin: Von A bis Z mit Codebeispielen

Entwurfsmuster in Kotlin mit Beispielen: Von A bis Z

Entwurfsmuster (design patterns) sind bewährte Lösungen für typische Entwicklungsaufgaben. In Kotlin werden dank seiner prägnanten Syntax und leistungsstarken Funktionen (data class, object, extension functions, Koroutinen) viele klassische Muster einfacher und eleganter implementiert als in Java. In diesem Artikel analysieren wir die wichtigsten Muster in Kotlin, von Erzeugungs- bis zu Verhaltensmustern, mit realen Codebeispielen.

1. Erzeugungsmuster (Creational)

Diese Muster verwalten den Prozess der Objekterstellung und machen das System unabhängig von der Art und Weise ihrer Erstellung.

1.1. Singleton (Einzelstück)

Garantiert, dass eine Klasse nur eine Instanz hat. In Kotlin wird dafür das Schlüsselwort object verwendet.

object DatabaseConnection {    val connectionString: String = "jdbc:postgresql://localhost:5432/mydb"

    fun connect() {        println("Connecting to $connectionString")    }}

fun main() {    DatabaseConnection.connect()    println(DatabaseConnection.connectionString)}

Wann verwenden: für Konfigurationsmanager, Thread-Pools, Caches.

1.2. Factory Method (Fabrikmethode)

Definiert eine Schnittstelle zum Erstellen eines Objekts, ermöglicht es Unterklassen jedoch, den Typ des zu erstellenden Objekts zu ändern.

// Abstraktes Produktinterface Notification {    fun send(message: String)}

// Konkrete Produkteclass EmailNotification : Notification {    override fun send(message: String) = println("Email: $message")}

class SMSNotification : Notification {    override fun send(message: String) = println("SMS: $message")}

// Fabrikabstract class NotificationFactory {    abstract fun createNotification(): Notification

    fun notifyUser(message: String) {        val notification = createNotification()        notification.send(message)    }}

class EmailFactory : NotificationFactory() {    override fun createNotification(): Notification = EmailNotification()}

class SMSFactory : NotificationFactory() {    override fun createNotification(): Notification = SMSNotification()}

fun main() {    val factory: NotificationFactory = EmailFactory()    factory.notifyUser("Hello from Kotlin!")}

Wann verwenden: wenn der Typ der zu erstellenden Objekte im Voraus nicht bekannt ist.

1.3. Builder (Erbauer)

Ermöglicht die schrittweise Erstellung komplexer Objekte. In Kotlin wird dies hervorragend mit apply und benannten Argumenten umgesetzt.

data class Pizza(    val size: String,    val cheese: Boolean = false,    val pepperoni: Boolean = false,    val mushrooms: Boolean = false) {    // Integrierter Builder    class Builder(private val size: String) {        private var cheese: Boolean = false        private var pepperoni: Boolean = false        private var mushrooms: Boolean = false

        fun cheese(value: Boolean) = apply { cheese = value }        fun pepperoni(value: Boolean) = apply { pepperoni = value }        fun mushrooms(value: Boolean) = apply { mushrooms = value }

        fun build() = Pizza(size, cheese, pepperoni, mushrooms)    }}

fun main() {    val pizza = Pizza.Builder("Large")        .cheese(true)        .pepperoni(true)        .build()    println(pizza)}

Wann verwenden: bei einer großen Anzahl optionaler Parameter.

2. Strukturmuster (Structural)

Diese Muster definieren Möglichkeiten, Klassen und Objekte zu größeren Strukturen zusammenzusetzen.

2.1. Adapter (Adapter)

Ermöglicht Objekten mit inkompatiblen Schnittstellen die Zusammenarbeit. In Kotlin wird dies häufig über extension functions realisiert.

// Alte Schnittstelleinterface OldLogger {    fun logMessage(msg: String)}

// Neue Schnittstelleinterface NewLogger {    fun log(level: Stri