Jak działa dziedziczenie w Kotlin?

Dziedziczenie w Kotlin opiera się na zasadzie otwartych klas. Domyślnie wszystkie klasy są zamknięte (final), a aby uczynić klasę dziedziczną, musi być ona wyraźnie oznaczona słowem kluczowym open.

Główne punkty:

Otwarte klasy: Klasa bazowa musi być oznaczona jako open.
```
open class Base {
    // ...
}
```
Dziedziczenie: Dziedziczenie odbywa się za pomocą dwukropka (:), po którym następuje nazwa klasy bazowej i, jeśli to konieczne, wywołanie jej konstruktora.
```
class Derived : Base() {
    // ...
}
```
Przesłanianie metod i właściwości: Aby przesłonić metody lub właściwości klasy bazowej, muszą one być oznaczone jako open w klasie bazowej, a w klasie pochodnej używa się słowa kluczowego override.
```
open class Base {
    open fun process() { /* ... */ }
    open val value: Int = 0
}

class Derived : Base() {
    override fun process() { /* ... */ }
    override val value: Int = 1
}
```
Jeśli metoda lub właściwość klasy bazowej nie jest oznaczona jako open, nie można jej przesłonić.

Dostęp do członków klasy bazowej: Dostęp do członków klasy bazowej z klasy pochodnej odbywa się za pomocą słowa kluczowego super.

class Derived : Base() {
    override fun process() {
        super.process() // Wywołanie metody klasy bazowej
        // ...
    }
}

Konstruktory: Jeśli klasa bazowa ma konstruktor z parametrami, klasa pochodna musi wywołać ten konstruktor w swojej sygnaturze.

open class Base(name: String) {
    // ...
}

class Derived(name: String, age: Int) : Base(name) {
    // ...
}

Interfejsy: Klasa może implementować wiele interfejsów, które można wskazać oddzielając je przecinkami po klasie bazowej (jeśli istnieje). Interfejsy domyślnie są "otwarte" do implementacji.
```
interface MyInterface {
    fun doSomething()
}

class MyClass : Base(), MyInterface {
    override fun doSomething() { /* ... */ }
}
```
Klasy abstrakcyjne: Klasy abstrakcyjne służą do definiowania częściowej implementacji i zawierają metody i właściwości abstrakcyjne (oznaczone abstract), które muszą być zaimplementowane w klasach pochodnych. Członkowie abstrakcyjni nie wymagają open. Klasa abstrakcyjna nie wymaga również open do dziedziczenia.
```
abstract class AbsBase {
    abstract fun abstractMethod()
    open fun concreteMethod() { /* ... */ }
}

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

Ogólnie, Kotlin dąży do jasności, wymagając użycia open do umożliwienia dziedziczenia i przesłaniania.