Come funziona l'ereditarietà in Kotlin?

L'ereditarietà in Kotlin si basa sul principio delle classi aperte. Per impostazione predefinita, tutte le classi sono chiuse (finale), e per rendere una classe ereditabile, deve essere esplicitamente contrassegnata con la parola chiave open.

Punti principali:

Classi aperte: La classe di base deve essere contrassegnata come open.
```
open class Base {
    // ...
}
```
Ereditarietà: L'ereditarietà si effettua con due punti (:), seguiti dal nome della classe di base e, se necessario, dalla chiamata al suo costruttore.
```
class Derived : Base() {
    // ...
}
```
Sovrascrittura di metodi e proprietà: Per sovrascrivere metodi o proprietà della classe di base, questi devono essere contrassegnati come open nella classe di base, e nella classe derivata si usa la parola chiave override.
```
open class Base {
    open fun process() { /* ... */ }
    open val value: Int = 0
}

class Derived : Base() {
    override fun process() { /* ... */ }
    override val value: Int = 1
}
```
Se il metodo o la proprietà della classe di base non sono contrassegnati come open, non possono essere sovrascritti.

Accesso ai membri della classe di base: L'accesso ai membri della classe di base dalla classe derivata avviene tramite la parola chiave super.

class Derived : Base() {
    override fun process() {
        super.process() // Chiamata al metodo della classe di base
        // ...
    }
}

Costruttori: Se la classe di base ha un costruttore con parametri, la classe derivata deve chiamare tale costruttore nella sua firma.
```
open class Base(name: String) {
    // ...
}

class Derived(name: String, age: Int) : Base(name) {
    // ...
}
```
Interfacce: Una classe può implementare più interfacce, e queste vengono indicate separate da virgole dopo la classe di base (se presente). Le interfacce sono di default "aperte" all'implementazione.
```
interface MyInterface {
    fun doSomething()
}

class MyClass : Base(), MyInterface {
    override fun doSomething() { /* ... */ }
}
```
Classi astratte: Le classi astratte sono usate per definire implementazioni parziali e contengono metodi e proprietà astratte (contrassegnate con abstract) che devono essere implementate nelle classi derivate. I membri astratti non richiedono open. La classe astratta non richiede open per essere ereditata.
```
abstract class AbsBase {
    abstract fun abstractMethod()
    open fun concreteMethod() { /* ... */ }
}

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

In generale, Kotlin mira alla chiarezza, richiedendo l'uso di open per consentire l'ereditarietà e la sovrascrittura.