Comment la mise en œuvre des interfaces se fait-elle…

Les interfaces en Kotlin sont implémentées en utilisant le mot-clé implements (implicite en Kotlin, simplement indiqué par deux points) ou by pour la délégation.

Principales méthodes d'implémentation :

Implémentation directe : L'objet ou la classe implémente directement tous les membres de l'interface.

interface MyInterface {
    fun doSomething()
    val myProperty: String
}

class MyClass : MyInterface {
    override fun doSomething() {
        println("Faire quelque chose dans MyClass")
    }

    override val myProperty: String = "Bonjour"
}

Lorsqu'une classe hérite d'une autre classe et implémente des interfaces en même temps, la classe est indiquée en premier.

open class BaseClass

class AnotherClass : BaseClass(), MyInterface {
    override fun doSomething() {
        println("Faire quelque chose dans AnotherClass")
    }

    override val myProperty: String = "Monde"
}

Délégation d'implémentation : L'implémentation de l'interface est déléguée à un autre objet. Utilise le mot-clé by. Ceci est utile pour la composition et pour éviter les problèmes d'héritage multiple d'implémentation.

interface DelegatedInterface {
    fun performAction()
}

class DelegatedObject : DelegatedInterface {
    override fun performAction() {
        println("Action effectuée par DelegatedObject")
    }
}

class ImplementingClass(di: DelegatedInterface) : DelegatedInterface by di {
    // ImplementingClass délègue l'implémentation de la méthode performAction() à l'objet di
}

Dans ce cas, ImplementingClass n'implémente pas performAction lui-même, à la place, l'appel à performingClass.performAction() est redirigé vers di.performAction().

Lors de l'implémentation de plusieurs interfaces avec des membres portant le même nom, il est nécessaire de résoudre les conflits en redéfinissant explicitement le membre et en indiquant de quelle interface provient l'implémentation, en utilisant la syntaxe <Interface>.<membre>.

interface InterfaceA {
    fun foo() { println("InterfaceA") }
    fun bar()
}

interface InterfaceB {
    fun foo() { println("InterfaceB") }
    fun bar() { println("InterfaceB bar") }
}

class ResolvingConflict : InterfaceA, InterfaceB {
    override fun foo() {
        super<InterfaceA>.foo() // Appel à l'implémentation de foo de InterfaceA
        super<InterfaceB>.foo() // Appel à l'implémentation de foo de InterfaceB
    }

    override fun bar() {
        super<InterfaceB>.bar() // Utilise l'implémentation de bar de InterfaceB
    }
}

Comment la mise en œuvre des interfaces se fait-elle en Kotlin?