Comment se fait l'héritage dans le langage Kotlin?

L'héritage en Kotlin repose sur les mots-clés open et override. Les classes et méthodes sont final par défaut, ce qui signifie qu'elles ne peuvent pas être héritées ou redéfinies. Pour autoriser l'héritage, la classe ou la méthode doit être marquée avec le modificateur open.

Pour créer une classe dérivée, on utilise deux points : après le nom de la classe de base, suivis du nom de la classe de base avec son constructeur.

open class Base(val name: String) {
    open fun greet() {
        println("Bonjour, $name")
    }
}

Pour redéfinir une méthode de la classe de base dans la classe dérivée, on utilise le modificateur override.

class Derived(name: String) : Base(name) {
    override fun greet() {
        println("Salutations, $name")
    }
}

Si la classe de base possède un constructeur avec des paramètres, la classe dérivée doit l'appeler en utilisant le mot-clé super.

Kotlin supporte l'héritage multiple d'interfaces, mais pas de classes. Une classe ne peut hériter que d'une seule autre classe.

Une classe peut également marquer ses membres comme protected, internal ou private, limitant leur visibilité pour les classes dérivées ou dans le module.

Les classes abstraites sont déclarées avec le mot-clé abstract. Elles peuvent contenir des méthodes abstraites (sans implémentation) ainsi que des méthodes normales. Les méthodes abstraites n'ont pas besoin du mot open, car leur redéfinition est implicite. Les classes abstraites ne peuvent pas être instanciées directement.

abstract class Shape {
    abstract fun draw()
    open fun printInfo() {
        println("Ceci est une forme.")
    }
}

Ainsi, l'héritage en Kotlin est explicitement contrôlé par les modificateurs open et override, ce qui améliore la lisibilité et empêche l'héritage indésirable.