Kotlin Academy · Lektion

Delegation oder Vererbung

Wählen Sie Komposition

Delegation oder Vererbung ist eine kostenlose Kotlin Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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.

Zwei Möglichkeiten zur Wiederverwendung

Vererbung und Delegation verwenden beide Verhalten wieder. Vererbung bedeutet, dass eine Klasse eine Art von einer anderen ist. Delegation bedeutet, dass eine Klasse einen Delegaten besitzt, an den sie Aufrufe weiterleitet.

Der klassische Rat lautet: Bevorzugen Sie Komposition gegenüber Vererbung.

Beispiel für Vererbung

Bei Vererbung erweitert eine Unterklasse eine Basisklasse und überschreibt Mitglieder. Die Basisklasse muss in Kotlin open sein.

open class Animal {
    open fun sound() = "..."
}

class Dog : Animal() {
    override fun sound() = "woof"
}

fun main() {
    println(Dog().sound())
}

Beispiel für Delegation

Dieselbe Wiederverwendung mit Delegation: Das Verhalten befindet sich in einem Member, an den die Klasse weiterleitet.

interface Sound { fun sound(): String }
class Bark : Sound { override fun sound() = "woof" }

class Dog(s: Sound) : Sound by s

fun main() {
    println(Dog(Bark()).sound())
}

Die fragile Basisklasse

Vererbung koppelt eine Unterklasse eng an die Interna ihrer übergeordneten Klasse. Eine Änderung an der Basisklasse kann Unterklassen unbemerkt beschädigen – das Problem der fragilen Basisklasse. Delegation hängt nur von der Schnittstelle ab.

Kapselung

Eine Unterklasse kann auf geschützte Member zugreifen und Hooks überschreiben, wodurch sie Einblick in die übergeordnete Klasse erhält. Eine delegierende Klasse sieht nur die öffentliche Schnittstelle und bewahrt dadurch die Kapselung.

interface Counter { fun increment(): Int }

class SimpleCounter : Counter {
    private var n = 0
    override fun increment(): Int { n++; return n }
}

class GuardedCounter(private val c: Counter) : Counter by c {
    override fun increment(): Int {
        println("incrementing")
        return c.increment()
    }
}

fun main() {
    val g = GuardedCounter(SimpleCounter())
    println(g.increment())
    println(g.increment())
}

Flexibilität zur Laufzeit

Vererbung legt die übergeordnete Klasse zur Kompilierungszeit fest. Mit Delegation können Sie zur Laufzeit verschiedene Implementierungen injizieren, was einfache Tests mit Fakes ermöglicht.

interface Clock { fun now(): Int }
class RealClock : Clock { override fun now() = 100 }
class FakeClock : Clock { override fun now() = 0 }

class Timer(c: Clock) : Clock by c

fun main() {
    println(Timer(RealClock()).now())
    println(Timer(FakeClock()).now()) // easy to test
}

Mehrere Verhaltensweisen

Eine Klasse kann nur eine übergeordnete Klasse erweitern, aber an viele Schnittstellen delegieren. Delegation lässt sich gut auf die Kombination mehrerer Fähigkeiten skalieren.

interface Walk { fun walk() = "walking" }
interface Swim { fun swim() = "swimming" }
class Walker : Walk
class Swimmer : Swim

class Amphibian : Walk by Walker(), Swim by Swimmer()

fun main() {
    val a = Amphibian()
    println(a.walk() + ", " + a.swim())
}

Wann Vererbung passt

Vererbung ist weiterhin die richtige Wahl für eine echte is-a-Beziehung mit einer stabilen, für Erweiterungen ausgelegten Hierarchie: versiegelte Typhierarchien, Framework-Basisklassen und Polymorphie über einen gemeinsamen abstrakten Typ.

sealed class Shape
class Circle(val r: Double) : Shape()
class Square(val s: Double) : Shape()

fun area(shape: Shape) = when (shape) {
    is Circle -> 3.14 * shape.r * shape.r
    is Square -> shape.s * shape.s
}

fun main() {
    println(area(Circle(2.0)))
}

Wann Delegation passt

Wählen Sie Delegation, wenn Sie:

Verhalten über nicht verwandte Typen hinweg wiederverwenden möchten
Mehrere Fähigkeiten kombinieren möchten
Die Kopplung gering und Tests einfach halten möchten
Vorhandene Implementierungen wrappen und dekorieren möchten

Gegenüberstellung

Vererbung: eine übergeordnete Klasse, enge Kopplung, zur Kompilierungszeit festgelegt, is-a. Delegation: viele Mitarbeiter, lose Kopplung, zur Laufzeit austauschbar, has-a. Kotlin macht Delegation mit by kostengünstig und verschiebt dadurch das Gleichgewicht in Richtung Komposition.

Eine sinnvolle Standardwahl

Eine gute Faustregel: Beginnen Sie mit Delegation. Wechseln Sie nur dann zu Vererbung, wenn sich eine echte, stabile is-a-Hierarchie herausbildet. So bleiben Entwürfe flexibel und widerstandsfähig gegenüber Änderungen.

Kurzer Test

Testen Sie Ihr Verständnis von Delegation und Vererbung.

Zusammenfassung

Sie haben die beiden Ansätze verglichen:

Vererbung: is-a, eine übergeordnete Klasse, enge Kopplung
Delegation: has-a, viele Mitarbeiter, lose Kopplung
Bevorzugen Sie Komposition; verwenden Sie Vererbung für stabile is-a-Hierarchien

Als Nächstes: praktische Decorator-Muster mit Delegation.

Häufig gestellte Fragen

Ist die Lektion „Delegation oder Vererbung“ kostenlos?

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

Wählen Sie Komposition 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 3 von 4.

Wie lange dauert die Lektion „Delegation oder Vererbung“?

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