Comment fonctionne l'héritage en Kotlin?

L’héritage en Kotlin repose sur le principe des classes ouvertes. Par défaut, toutes les classes sont fermées (final), et pour rendre une classe héritable, il faut explicitement la marquer avec le mot-clé open.

Points clés :

Classes ouvertes : La classe de base doit être marquée comme open.
```
open class Base {
    // ...
}
```
Héritage : L’héritage se fait avec deux points (:), suivis du nom de la classe de base et, si nécessaire, de l’appel à son constructeur.
```
class Derived : Base() {
    // ...
}
```
Redéfinition de méthodes et propriétés : Pour redéfinir des méthodes ou propriétés de la classe de base, celles-ci doivent être marquées comme open dans la classe de base, et dans la classe dérivée, on utilise le mot-clé override.
```
open class Base {
    open fun process() { /* ... */ }
    open val value: Int = 0
}

class Derived : Base() {
    override fun process() { /* ... */ }
    override val value: Int = 1
}
```
Si la méthode ou la propriété de la classe de base n’est pas marquée comme open, elle ne peut pas être redéfinie.

Accès aux membres de la classe de base : L’accès aux membres de la classe de base depuis la classe dérivée se fait avec le mot-clé super.

class Derived : Base() {
    override fun process() {
        super.process() // Appel à la méthode de la classe de base
        // ...
    }
}

Constructeurs : Si la classe de base possède un constructeur avec des paramètres, la classe dérivée doit appeler ce constructeur dans sa signature.
```
open class Base(name: String) {
    // ...
}

class Derived(name: String, age: Int) : Base(name) {
    // ...
}
```
Interfaces : Une classe peut implémenter plusieurs interfaces, qui sont indiquées séparément par des virgules après la classe de base (si elle existe). Les interfaces sont par défaut "ouvertes" pour l’implémentation.
```
interface MyInterface {
    fun doSomething()
}

class MyClass : Base(), MyInterface {
    override fun doSomething() { /* ... */ }
}
```
Classes abstraites : Les classes abstraites sont utilisées pour définir une implémentation partielle et contiennent des méthodes et propriétés abstraites (marquées avec abstract) qui doivent être implémentées dans les classes dérivées. Les membres abstraits ne nécessitent pas open. La classe abstraite n’a pas besoin d’être marquée open pour être héritée.
```
abstract class AbsBase {
    abstract fun abstractMethod()
    open fun concreteMethod() { /* ... */ }
}

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

En général, Kotlin privilégie la clarté, en exigeant l’utilisation de open pour permettre l’héritage et la redéfinition.