Kotlin Academy · Lektion

Delegation an Member

Komponieren Sie Verhalten

Delegation an Member ist eine kostenlose Kotlin Academy-Lektion auf CoddyKit. Dies ist Lektion 2 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.

Verhalten komponieren

Reale Objekte müssen oft mehrere Fähigkeiten kombinieren. Statt von vielen Quellen zu erben, können Sie jede Fähigkeit an ein dafür vorgesehenes Memberobjekt delegieren.

Zwei Rollen, eine Klasse

Angenommen, eine Klasse soll sowohl lesen als auch schreiben. Definieren Sie zwei Schnittstellen und delegieren Sie jede an eine eigene Implementierung.

interface Reader { fun read(): String }
interface Writer { fun write(s: String): String }

class FileReader : Reader { override fun read() = "contents" }
class FileWriter : Writer { override fun write(s: String) = "wrote " + s }

class FileIO(r: Reader, w: Writer) : Reader by r, Writer by w

fun main() {
    val io = FileIO(FileReader(), FileWriter())
    println(io.read())
    println(io.write("data"))
}

Mehrere Delegaten

Eine Klasse kann mehrere Schnittstellen gleichzeitig delegieren, jeweils an ein anderes Member. Die Klasse komponiert deren Verhalten ohne Vererbung.

interface Logger { fun log(m: String): String }
interface Validator { fun valid(m: String): Boolean }

class ConsoleLogger : Logger { override fun log(m: String) = "LOG: " + m }
class LengthValidator : Validator { override fun valid(m: String) = m.isNotEmpty() }

class Service(l: Logger, v: Validator) : Logger by l, Validator by v

fun main() {
    val s = Service(ConsoleLogger(), LengthValidator())
    println(s.valid("hi"))
    println(s.log("started"))
}

Delegat als Member gespeichert

Wenn Sie innerhalb von Überschreibungen auf den Delegaten zugreifen müssen, speichern Sie ihn als Konstruktor-Eigenschaft. Dieselbe Instanz wird sowohl für die Weiterleitung als auch für Ihren eigenen Code verwendet.

interface Cache { fun get(k: String): String }

class MapCache : Cache {
    override fun get(k: String) = "value-of-" + k
}

class TracingCache(private val inner: Cache) : Cache by inner {
    override fun get(k: String): String {
        println("lookup " + k)
        return inner.get(k)
    }
}

fun main() {
    println(TracingCache(MapCache()).get("id"))
}

Delegation und eigenen Zustand kombinieren

Eine delegierende Klasse kann neben den weitergeleiteten Mitgliedern eigene Eigenschaften und Methoden hinzufügen und so das zusammengesetzte Objekt erweitern.

interface Engine { fun start(): String }
class V8 : Engine { override fun start() = "vroom" }

class Car(e: Engine) : Engine by e {
    var doors = 4
    fun honk() = "beep"
}

fun main() {
    val c = Car(V8())
    println(c.start())
    println(c.honk())
    println(c.doors)
}

Implementierungen austauschen

Da der Delegat lediglich ein Member ist, können Sie denselben Wrapper mit unterschiedlichen zugrunde liegenden Implementierungen erstellen und das Verhalten zur Laufzeit auswählen.

interface Notifier { fun send(msg: String): String }
class EmailNotifier : Notifier { override fun send(msg: String) = "email: " + msg }
class SmsNotifier : Notifier { override fun send(msg: String) = "sms: " + msg }

class Alerts(n: Notifier) : Notifier by n

fun main() {
    println(Alerts(EmailNotifier()).send("hi"))
    println(Alerts(SmsNotifier()).send("hi"))
}

An eine Eigenschaft delegieren

Der Ausdruck nach by kann jeder einmal ausgewertete Ausdruck sein, einschließlich eines Konstruktoraufrufs. Er muss kein Parameter sein.

interface Greeter { fun greet() = "hi" }
class DefaultGreeter : Greeter

class Page : Greeter by DefaultGreeter()

fun main() {
    println(Page().greet())
}

Das Diamantproblem vermeiden

Mehrfachvererbung von Verhalten ist bei Klassen nicht möglich. Durch die Delegation mehrerer Schnittstellen an getrennte Member lässt sich das klassische Diamantproblem jedoch sauber umgehen.

interface A { fun a() = "A" }
interface B { fun b() = "B" }
class AImpl : A
class BImpl : B

class Combined : A by AImpl(), B by BImpl()

fun main() {
    val c = Combined()
    println(c.a() + c.b())
}

Für Komposition entwerfen

Für eine gute Komposition:

Definieren Sie kleine, fokussierte Schnittstellen
Stellen Sie wiederverwendbare Implementierungen bereit
Delegieren Sie jede Rolle in der komponierenden Klasse

So bleiben Klassen flexibel und testbar.

Zusammenfassung der Memberdelegation

Durch die Delegation an Memberobjekte kann eine Klasse ihr Verhalten aus einzelnen Teilen zusammensetzen. Sie können viele Schnittstellen kombinieren, selektiv überschreiben, Implementierungen austauschen und eigenen Zustand hinzufügen – alles ohne Vererbung.

Als Nächstes: Ein direkter Vergleich

Sie haben gesehen, wie flexibel Delegation ist. In der nächsten Lektion wird Delegation direkt der Vererbung gegenübergestellt, damit Sie wissen, wann Sie welche verwenden sollten.

Kurzer Test

Testen Sie Ihr Verständnis der Delegation an Member.

Zusammenfassung

Sie haben Memberdelegation kennengelernt:

Mehrere Schnittstellen an getrennte Objekte delegieren
Selektiv überschreiben und eigenen Zustand hinzufügen
Implementierungen beim Erstellen austauschen
Fallstricke der Mehrfachvererbung vermeiden

Als Nächstes: Delegation gegenüber Vererbung.

Häufig gestellte Fragen

Ist die Lektion „Delegation an Member“ kostenlos?

Ja — der vollständige Text von „Delegation an Member“ 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 „Delegation an Member“?

Komponieren Sie Verhalten 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 2 von 4.

Wie lange dauert die Lektion „Delegation an Member“?

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