Kotlin Academy · Lektion

Praktische Muster

Decoratoren mit Delegation

Praktische Muster ist eine kostenlose Kotlin Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Kotlin Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Das Decorator-Muster

Ein Decorator wrappt ein Objekt, um Verhalten hinzuzufügen, und behält dabei dieselbe Schnittstelle bei. Kotlin macht Decorators mit dem Schlüsselwort by ganz einfach: Leiten Sie alles weiter und überschreiben Sie nur die Teile, die Sie erweitern.

Eine Basiskomponente

Wir beginnen mit einer einfachen Datenquelle. Die Decorators werden diese wrappen.

interface DataSource {
    fun fetch(): String
}

class NetworkSource : DataSource {
    override fun fetch() = "raw-data"
}

fun main() {
    println(NetworkSource().fetch())
}

Ein Logging-Decorator

Der Decorator delegiert an die gewrappte Quelle und fügt beim Aufruf, der ihn interessiert, Logging hinzu.

interface DataSource { fun fetch(): String }
class NetworkSource : DataSource { override fun fetch() = "raw-data" }

class LoggingSource(private val inner: DataSource) : DataSource by inner {
    override fun fetch(): String {
        println("fetching...")
        val result = inner.fetch()
        println("done")
        return result
    }
}

fun main() {
    println(LoggingSource(NetworkSource()).fetch())
}

Ein Caching-Decorator

Ein weiterer Decorator speichert das erste Ergebnis zwischen, sodass wiederholte Aufrufe die zugrunde liegende Quelle überspringen.

interface DataSource { fun fetch(): String }
class NetworkSource : DataSource { override fun fetch() = "raw-data" }

class CachingSource(private val inner: DataSource) : DataSource by inner {
    private var cached: String? = null
    override fun fetch(): String {
        return cached ?: inner.fetch().also { cached = it }
    }
}

fun main() {
    val s = CachingSource(NetworkSource())
    println(s.fetch())
    println(s.fetch()) // served from cache
}

Decorator-Stacks

Da jeder Decorator selbst eine DataSource ist, können Sie sie stapeln. Die Reihenfolge ist wichtig: Der äußere Decorator wrappt den inneren.

interface DataSource { fun fetch(): String }
class NetworkSource : DataSource { override fun fetch() = "raw-data" }

class LoggingSource(private val inner: DataSource) : DataSource by inner {
    override fun fetch(): String { println("log"); return inner.fetch() }
}
class CachingSource(private val inner: DataSource) : DataSource by inner {
    private var c: String? = null
    override fun fetch() = c ?: inner.fetch().also { c = it }
}

fun main() {
    val s = LoggingSource(CachingSource(NetworkSource()))
    println(s.fetch())
    println(s.fetch())
}

Ein validierender Decorator

Decorators können auch Eingaben absichern. Hier validiert ein Decorator die Eingabe, bevor er an den eigentlichen Worker delegiert.

interface Processor { fun process(input: String): String }
class UpperProcessor : Processor { override fun process(input: String) = input.uppercase() }

class ValidatingProcessor(private val inner: Processor) : Processor by inner {
    override fun process(input: String): String {
        require(input.isNotBlank()) { "empty input" }
        return inner.process(input)
    }
}

fun main() {
    println(ValidatingProcessor(UpperProcessor()).process("hello"))
}

Wrapper für eine schreibgeschützte Collection

Mit Delegation lassen sich Adapter-Wrapper einfach erstellen. Hier wrappen wir eine Liste und fügen eine benutzerdefinierte Zusammenfassungsmethode hinzu, während wir alle Listenoperationen weiterleiten.

class SummarizedList(private val inner: List<Int>) : List<Int> by inner {
    fun total() = inner.sum()
}

fun main() {
    val list = SummarizedList(listOf(1, 2, 3))
    println(list.size)
    println(list.total())
}

Aufrufe zählen

Ein Decorator kann transparent Metriken erfassen – nützlich für das Monitoring, ohne die eigentliche Implementierung anzufassen.

interface Service { fun call(): String }
class RealService : Service { override fun call() = "ok" }

class CountingService(private val inner: Service) : Service by inner {
    var calls = 0
        private set
    override fun call(): String {
        calls++
        return inner.call()
    }
}

fun main() {
    val s = CountingService(RealService())
    s.call(); s.call()
    println(s.calls)
}

Warum Delegation hier überlegen ist

Das Erstellen von Decorators durch Vererbung würde voraussetzen, dass die Basisklasse open ist, und jeden Decorator an eine konkrete Klasse binden. Delegation hängt nur von der Schnittstelle ab, sodass Decorators lose gekoppelt und kombinierbar bleiben.

Checkliste für das Muster

So erstellen Sie einen Delegations-Decorator:

Übernehmen Sie das gewrappte Objekt als private val
Delegieren Sie die Schnittstelle mit by
Überschreiben Sie nur die Member, die Sie erweitern
Rufen Sie innerhalb der Überschreibung das innere Objekt auf

Alles zusammenführen

Decorators, Adapter und Proxys ergeben sich ganz natürlich aus Klassendelegation. Zusammen mit kleinen Schnittstellen ermöglichen sie den Aufbau flexibler, geschichteter Systeme, die einfach zu testen und zu erweitern sind.

Kurzer Test

Testen Sie Ihr Verständnis praktischer Delegationsmuster.

Zusammenfassung

Sie haben praktische Decorators mit Delegation erstellt:

Wrapper für Logging, Caching, Validierung und Zählung
Gestapelte Decorators, da jeder dieselbe Schnittstelle implementiert
Nur die erweiterten Member überschreiben und den Rest weiterleiten

Damit ist der Kurs zur Klassendelegation abgeschlossen.

Häufig gestellte Fragen

Ist die Lektion „Praktische Muster“ kostenlos?

Ja — der vollständige Text von „Praktische Muster“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Kotlin Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Praktische Muster“?

Decoratoren mit Delegation Du übst Kotlin Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Kotlin Academy zu starten?

Keine Vorkenntnisse erforderlich. Kotlin Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Praktische Muster“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Kotlin Academy-Lektion Code schreiben und ausführen?

Ja. Jede Kotlin Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Kotlin Academy