Hoe werkt erfelijkheid in Kotlin?

Overerving in Kotlin is gebaseerd op het principe van open klassen. Standaard zijn alle klassen final (gesloten), en om een klasse erfenisbaar te maken, moet deze expliciet worden gemarkeerd met het sleutelwoord open.

Belangrijke punten:

Open klassen: De basisklasse moet worden gemarkeerd als open.
```
open class Base {
    // ...
}
```
Erfenis: Erfenis wordt gedaan met behulp van een dubbele punt (:), gevolgd door de naam van de basisklasse en indien nodig, de aanroep van de constructor.
```
class Derived : Base() {
    // ...
}
```
Overschrijven van methoden en eigenschappen: Om methoden of eigenschappen van de basisklasse te overschrijven, moeten deze in de basisklasse worden gemarkeerd als open, en in de afgeleide klasse wordt override gebruikt.
```
open class Base {
    open fun process() { /* ... */ }
    open val value: Int = 0
}

class Derived : Base() {
    override fun process() { /* ... */ }
    override val value: Int = 1
}
```
Als de methode of eigenschap van de basisklasse niet is gemarkeerd als open, kan deze niet worden overschreven.

Toegang tot leden van de basisklasse: Toegang tot de leden van de basisklasse vanuit de afgeleide klasse gebeurt met super.

class Derived : Base() {
    override fun process() {
        super.process() // Aanroep van de methode van de basisklasse
        // ...
    }
}

Constructors: Als de basisklasse een constructor met parameters heeft, moet de afgeleide klasse deze constructor aanroepen in haar handtekening.
```
open class Base(name: String) {
    // ...
}

class Derived(name: String, age: Int) : Base(name) {
    // ...
}
```
Interfaces: Een klasse kan meerdere interfaces implementeren, en deze worden aangegeven gescheiden door komma's na de erfenis van de klasse (indien aanwezig). Interfaces zijn standaard "open" voor implementatie.
```
interface MyInterface {
    fun doSomething()
}

class MyClass : Base(), MyInterface {
    override fun doSomething() { /* ... */ }
}
```
Abstracte klassen: Abstracte klassen worden gebruikt om een gedeeltelijke implementatie te definiëren en bevatten abstracte methoden en eigenschappen (aangeduid met abstract) die in afgeleide klassen moeten worden geïmplementeerd. Abstracte leden vereisen geen open. Een abstracte klasse hoeft ook niet open te zijn om te worden geërfd.
```
abstract class AbsBase {
    abstract fun abstractMethod()
    open fun concreteMethod() { /* ... */ }
}

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

Over het algemeen streeft Kotlin naar duidelijkheid, en vereist het gebruik van open voor het toestaan van erfenis en overschrijven.