Cum funcționează moștenirea în Kotlin?

Moștenirea în Kotlin se bazează pe principiul claselor deschise. În mod implicit, toate clasele sunt închise (final), iar pentru a face o clasă moștenibilă, trebuie să fie marcată explicit cu cuvântul cheie open.

Puncte cheie:

Clase deschise: Clasa de bază trebuie să fie marcată ca open.
```
open class Base {
    // ...
}
```
Moștenire: Moștenirea se face cu ajutorul două puncte (:), urmat de numele clasei de bază și, dacă este necesar, apelul constructorului acesteia.
```
class Derived : Base() {
    // ...
}
```
Suprascrierea metodelor și proprietăților: Pentru a suprascrie metode sau proprietăți ale clasei de bază, acestea trebuie să fie marcate ca open în clasa de bază, iar în clasa derivată se folosește cuvântul cheie override.
```
open class Base {
    open fun process() { /* ... */ }
    open val value: Int = 0
}

class Derived : Base() {
    override fun process() { /* ... */ }
    override val value: Int = 1
}
```
Dacă metoda sau proprietatea clasei de bază nu este marcată ca open, nu poate fi suprascrisă.

Accesul la membrii clasei de bază: Accesul la membrii clasei de bază din clasa derivată se face cu ajutorul cuvântului cheie super.

class Derived : Base() {
    override fun process() {
        super.process() // Apelul metodei clasei de bază
        // ...
    }
}

Constructorii: Dacă clasa de bază are un constructor cu parametri, clasa derivată trebuie să apeleze acest constructor în semnătura sa.
```
open class Base(name: String) {
    // ...
}

class Derived(name: String, age: Int) : Base(name) {
    // ...
}
```
Interfețe: O clasă poate implementa mai multe interfețe, iar acestea pot fi indicate separate prin virgulă după clasa de bază (dacă există). Interfețele sunt, implicit, "deschise" pentru implementare.
```
interface MyInterface {
    fun doSomething()
}

class MyClass : Base(), MyInterface {
    override fun doSomething() { /* ... */ }
}
```
Clase abstracte: Clasele abstracte sunt utilizate pentru a defini o implementare parțială și conțin metode și proprietăți abstracte (marcate cu abstract) care trebuie implementate în clasele derivate. Membrii abstracti nu necesită open. Clasa abstractă nu necesită, de asemenea, open pentru moștenire.
```
abstract class AbsBase {
    abstract fun abstractMethod()
    open fun concreteMethod() { /* ... */ }
}

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

În general, Kotlin tinde spre claritate, cerând utilizarea open pentru a permite moștenirea și suprascrierea.