Wie funktioniert Vererbung in Kotlin?

Die Vererbung in Kotlin basiert auf dem Prinzip offener Klassen. Standardmäßig sind alle Klassen final (geschlossen), und um eine Klasse vererbbar zu machen, muss sie explizit mit dem Schlüsselwort open gekennzeichnet werden.

Wichtige Punkte:

Offene Klassen: Die Basisklasse muss mit open gekennzeichnet sein.
```
open class Base {
    // ...
}
```
Vererbung: Die Vererbung erfolgt durch Doppelpunkt (:), gefolgt vom Namen der Basisklasse und bei Bedarf dem Aufruf ihres Konstruktors.
```
class Derived : Base() {
    // ...
}
```
Überschreiben von Methoden und Eigenschaften: Um Methoden oder Eigenschaften der Basisklasse zu überschreiben, müssen diese in der Basisklasse mit open gekennzeichnet sein, und in der abgeleiteten Klasse wird override verwendet.
```
open class Base {
    open fun process() { /* ... */ }
    open val value: Int = 0
}

class Derived : Base() {
    override fun process() { /* ... */ }
    override val value: Int = 1
}
```
Wenn die Methode oder Eigenschaft der Basisklasse nicht mit open gekennzeichnet ist, kann sie nicht überschrieben werden.

Zugriff auf Mitglieder der Basisklasse: Der Zugriff auf Mitglieder der Basisklasse aus der abgeleiteten Klasse erfolgt mit super.

class Derived : Base() {
    override fun process() {
        super.process() // Aufruf der Methode der Basisklasse
        // ...
    }
}

Konstruktoren: Wenn die Basisklasse einen Konstruktor mit Parametern hat, muss die abgeleitete Klasse diesen Konstruktor in ihrer Signatur aufrufen.
```
open class Base(name: String) {
    // ...
}

class Derived(name: String, age: Int) : Base(name) {
    // ...
}
```
Schnittstellen: Eine Klasse kann mehrere Schnittstellen implementieren, die durch Kommas getrennt nach der Basisklasse angegeben werden (falls vorhanden). Schnittstellen sind standardmäßig "offen" für die Implementierung.
```
interface MyInterface {
    fun doSomething()
}

class MyClass : Base(), MyInterface {
    override fun doSomething() { /* ... */ }
}
```
Abstrakte Klassen: Abstrakte Klassen werden verwendet, um eine teilweise Implementierung zu definieren und enthalten abstrakte Methoden und Eigenschaften (mit abstract gekennzeichnet), die in den abgeleiteten Klassen implementiert werden müssen. Abstrakte Mitglieder benötigen kein open. Abstrakte Klassen benötigen auch kein open für die Vererbung.
```
abstract class AbsBase {
    abstract fun abstractMethod()
    open fun concreteMethod() { /* ... */ }
}

class AbsDerived : AbsBase() {
    override fun abstractMethod() { /* ... */ }
}
```

Insgesamt strebt Kotlin nach Klarheit und verlangt die Verwendung von open für Vererbung und Überschreibung.