Explique comment fonctionne le mot-clé 'super' dans…

Le mot-clé super est utilisé pour accéder aux membres (propriétés, méthodes) de la classe parente depuis la classe enfant.

Les principales utilisations :

Appel du constructeur de la classe parente : Souvent utilisé dans le constructeur de la classe enfant pour appeler le constructeur correspondant du parent. Cela est obligatoire si la classe parente possède un constructeur primaire avec des paramètres.
```
open class Parent(val name: String)

class Child(name: String) : Parent(name) {
    // Le constructeur de Child appelle celui de Parent,
    // en passant le paramètre name.
}
```

Accès aux membres de la classe parente, redéfinis dans la classe enfant : Permet d’accéder à l’implémentation d’une méthode ou propriété dans la classe parente, même si elle a été redéfinie (avec override) dans la classe enfant.

open class Base {
    open fun greet() {
        println("Hello from Base")
    }

    open val value: Int = 1
}

class Derived : Base() {
    override fun greet() {
        super.greet() // Appel de greet() depuis Base
        println("Hello from Derived")
    }

    override val value: Int = 2
        get() {
            println("Accès à la valeur de Derived")
            return super.value + 1 // Accès à value depuis Base
        }
}

Accès aux membres d’un type supérieur spécifique (en cas d’héritage multiple d’interfaces) : Si une classe implémente plusieurs interfaces ayant des membres avec des noms identiques, super avec la spécification du nom de l’interface dans des crochets angulaires (super<TypeName>) permet de désigner de manière précise le membre de quelle interface appeler.

interface MyInterface1 {
    fun foo() { println("MyInterface1 foo") }
}

interface MyInterface2 {
    fun foo() { println("MyInterface2 foo") }
}

class MyClass : MyInterface1, MyInterface2 {
    override fun foo() {
        super<MyInterface1>.foo() // Appel de foo() de MyInterface1
        super<MyInterface2>.foo() // Appel de foo() de MyInterface2
    }
}

Explique comment fonctionne le mot-clé 'super' dans le langage Kotlin.