Ako funguje dedičstvo v Kotlin?

Dedičnosť v Kotlin je založená na princípe otvorených tried. Predvolene sú všetky triedy uzavreté (final), a aby bola trieda dediťelná, musí byť výslovne označená kľúčovým slovom open.

Hlavné body:

Otvorné triedy: Trieda rodiča musí byť označená ako open.
```
open class Base {
    // ...
}
```
Dedičstvo: Dedičstvo sa vykonáva pomocou dvojbodky (:), za ktorou nasleduje názov rodičovskej triedy a, ak je to potrebné, volanie jej konštruktora.
```
class Derived : Base() {
    // ...
}
```
Prepisovanie metód a vlastností: Na prepisovanie metód alebo vlastností rodičovskej triedy musia byť tieto označené v rodičovskej triede ako open, a v odvodenom triede je potrebné použiť kľúč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
}
```
Ak rodičovská metóda alebo vlastnosť neboli označené ako open, nemôžu byť prepísané.

Prístup k členom rodičovskej triedy: Prístup k členom rodičovskej triedy z odvodeného triedy sa vykonáva pomocou kľúčového slova super.

class Derived : Base() {
    override fun process() {
        super.process() // Volanie metódy rodičovskej triedy
        // ...
    }
}

Konštruktory: Ak má rodičovská trieda konštruktor s parametrami, odvodená trieda musí tento konštruktor volať v svojej deklarácii.
```
open class Base(name: String) {
    // ...
}

class Derived(name: String, age: Int) : Base(name) {
    // ...
}
```
Rozhrania: Trieda môže implementovať viac rozhraní, ktoré je možné uviesť za dedičnou triedou oddelené čiarkou. Rozhrania sú predvolene "otvorené" na implementáciu.
```
interface MyInterface {
    fun doSomething()
}

class MyClass : Base(), MyInterface {
    override fun doSomething() { /* ... */ }
}
```
Abstraktné triedy: Abstraktné triedy slúžia na definovanie čiastočnej implementácie a obsahujú abstraktné metódy a vlastnosti (označené abstract), ktoré musia byť implementované v odvodených triedach. Abstraktné členy nevyžadujú open. Abstraktná trieda tiež nevyžaduje open na dedenie.
```
abstract class AbsBase {
    abstract fun abstractMethod()
    open fun concreteMethod() { /* ... */ }
}

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

Celkovo Kotlin smeruje k jasnosti, vyžadujúc použitie open na povolenie dedenia a prepisovania.