Hogyan működik az öröklődés Kotlinben?

A Kotlin öröklődés az nyitott osztályok elvén alapul. Alapértelmezés szerint minden osztály final (zárt), és hogy egy osztály örökölhető legyen, azt explicit módon az open kulcsszóval kell megjelölni.

Főbb pontok:

Nyitott osztályok: Az alap osztálynak open-nak kell lennie.
```
open class Base {
    // ...
}
```
Öröklés: Az öröklés két pont (:) segítségével történik, amit az alap osztály neve követ, és szükség esetén a konstruktorának hívása.
```
class Derived : Base() {
    // ...
}
```
Metódusok és tulajdonságok felülírása: Az alap osztály metódusait vagy tulajdonságait felülírni csak akkor lehet, ha azok open-ként vannak megjelölve, és a leszármazott osztályban override-ot használunk.
```
open class Base {
    open fun process() { /* ... */ }
    open val value: Int = 0
}

class Derived : Base() {
    override fun process() { /* ... */ }
    override val value: Int = 1
}
```
Ha az alap osztály metódusa vagy tulajdonsága nem open, akkor nem lehet felülírni.

Hozzáférés az alap osztály tagjaihoz: Az alap osztály tagjaihoz a leszármazott osztályból a super kulcsszóval lehet hozzáférni.

class Derived : Base() {
    override fun process() {
        super.process() // Az alap osztály metódusának hívása
        // ...
    }
}

Konstruktorok: Ha az alap osztálynak van paraméteres konstruktora, akkor a leszármazott osztálynak ezt a konstruktort kell hívnia a szignatúrájában.
```
open class Base(name: String) {
    // ...
}

class Derived(name: String, age: Int) : Base(name) {
    // ...
}
```
Interfészek: Egy osztály több interfészt is megvalósíthat, ezeket vesszővel elválasztva írjuk a leszármazott osztály után (ha van). Az interfészek alapértelmezés szerint "nyitottak" a megvalósításra.
```
interface MyInterface {
    fun doSomething()
}

class MyClass : Base(), MyInterface {
    override fun doSomething() { /* ... */ }
}
```
Absztrakt osztályok: Az absztrakt osztályokat részleges implementációk meghatározására használják, és tartalmaznak absztrakt metódusokat és tulajdonságokat (abstract), amelyeket a leszármazott osztályoknak kell megvalósítaniuk. Az absztrakt tagoknak nem kell open-nak lenniük. Az absztrakt osztály sem igényel open-t az örökléshez.
```
abstract class AbsBase {
    abstract fun abstractMethod()
    open fun concreteMethod() { /* ... */ }
}

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

Általánosságban, a Kotlin a világos kódot preferálja, és az open használatát írja elő az öröklés és felülírás engedélyezéséhez.