Jak funguje dědičnost v Kotlinu?

Dědičnost v Kotlinu je založena na principu otevřených tříd. Ve výchozím nastavení jsou všechny třídy uzavřené (final) a aby byla třída děditelná, musí být výslovně označena klíčovým slovem open.

Hlavní body:

Otevřené třídy: Třída rodiče musí být označena jako open.
```
open class Base {
    // ...
}
```
Dědičnost: Dědičnost se provádí pomocí dvojtečky (:), za kterou následuje jméno rodičovské třídy a případně volání jejího konstruktoru.
```
class Derived : Base() {
    // ...
}
```
Přepsání metod a vlastností: Pro přepsání metod nebo vlastností rodičovské třídy musí být tyto označeny v rodičovské třídě jako open, a v odvozené třídě je nutné použít klíčové slovo override.
```
open class Base {
    open fun process() { /* ... */ }
    open val value: Int = 0
}

class Derived : Base() {
    override fun process() { /* ... */ }
    override val value: Int = 1
}
```
Pokud rodičovská metoda nebo vlastnost nebyly označeny jako open, nelze je přepsat.

Přístup k členům rodičovské třídy: Přístup k členům rodičovské třídy z odvozené třídy se provádí pomocí klíčového slova super.

class Derived : Base() {
    override fun process() {
        super.process() // Volání metody rodičovské třídy
        // ...
    }
}

Konstruktory: Pokud má rodičovská třída konstruktor s parametry, odvozená třída musí tento konstruktor volat ve své deklaraci.
```
open class Base(name: String) {
    // ...
}

class Derived(name: String, age: Int) : Base(name) {
    // ...
}
```
Rozhraní: Třída může implementovat více rozhraní, která lze uvést za děděnou třídou oddělená čárkou (pokud je). Rozhraní jsou ve výchozím nastavení "otevřená" pro implementaci.
```
interface MyInterface {
    fun doSomething()
}

class MyClass : Base(), MyInterface {
    override fun doSomething() { /* ... */ }
}
```
Abstraktní třídy: Abstraktní třídy slouží k definování částečné implementace a obsahují abstraktní metody a vlastnosti (označené abstract), které musí být implementovány v odvozených třídách. Abstraktní členové nevyžadují open. Abstraktní třída také nevyžaduje open pro dědění.
```
abstract class AbsBase {
    abstract fun abstractMethod()
    open fun concreteMethod() { /* ... */ }
}

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

Celkově Kotlin směřuje k jasnosti, vyžadující použití open pro povolení dědění a přepsání.