Kotlin
Interfaces

Remarques

Interface de base

Une interface Kotlin contient des déclarations de méthodes abstraites et des implémentations de méthodes par défaut bien qu'elles ne puissent pas stocker d'état.

interface MyInterface {
    fun bar()
}

Cette interface peut maintenant être implémentée par une classe comme suit:

class Child : MyInterface {
   override fun bar() {
       print("bar() was called")
   }
}

Interface avec les implémentations par défaut

Une interface dans Kotlin peut avoir des implémentations par défaut pour les fonctions:

interface MyInterface {
    fun withImplementation() {
      print("withImplementation() was called")
    }
}

Les classes implémentant de telles interfaces pourront utiliser ces fonctions sans les réimplémenter

class MyClass: MyInterface {
    // No need to reimplement here
}
val instance = MyClass()
instance.withImplementation()

Propriétés

Les implémentations par défaut fonctionnent également pour les getters et les setters de propriété:

interface MyInterface2 {
    val helloWorld
        get() = "Hello World!"
}

Les implémentations d'interface ne peuvent pas utiliser les champs de sauvegarde

interface MyInterface3 {
    // this property won't compile!
    var helloWorld: Int
        get() = field
        set(value) { field = value }
}

Implémentations multiples

Lorsque plusieurs interfaces implémentent la même fonction ou qu'elles définissent toutes avec une ou plusieurs implémentations, la classe dérivée doit résoudre manuellement les appels appropriés

interface A {
    fun notImplemented()
    fun implementedOnlyInA() { print("only A") }
    fun implementedInBoth() { print("both, A") }
    fun implementedInOne() { print("implemented in A") }
}

interface B {
    fun implementedInBoth() { print("both, B") }
    fun implementedInOne() // only defined
}

class MyClass: A, B {
    override fun notImplemented() { print("Normal implementation") }

    // implementedOnlyInA() can by normally used in instances

    // class needs to define how to use interface functions
    override fun implementedInBoth() {
        super<B>.implementedInBoth()
        super<A>.implementedInBoth()
    }

    // even if there's only one implementation, there multiple definitions
    override fun implementedInOne() {
        super<A>.implementedInOne()
        print("implementedInOne class implementation")
    }
}

Propriétés dans les interfaces

Vous pouvez déclarer des propriétés dans les interfaces. Une interface ne pouvant pas avoir d'état, vous ne pouvez déclarer qu'une propriété comme abstraite ou en fournissant une implémentation par défaut pour les accesseurs.

interface MyInterface {
    val property: Int // abstract

    val propertyWithImplementation: String
        get() = "foo"

    fun foo() {
        print(property)
    }
}

class Child : MyInterface {
    override val property: Int = 29
}

Conflits lors de l'implémentation de plusieurs interfaces avec des implémentations par défaut

Lors de l'implémentation de plusieurs interfaces ayant des méthodes du même nom incluant des implémentations par défaut, le compilateur est ambigu quant à l'implémentation à utiliser. En cas de conflit, le développeur doit remplacer la méthode en conflit et fournir une implémentation personnalisée. Cette implémentation peut choisir de déléguer ou non aux implémentations par défaut.

interface FirstTrait {
    fun foo() { print("first") }
    fun bar()
}

interface SecondTrait {
    fun foo() { print("second") }
    fun bar() { print("bar") }
}

class ClassWithConflict : FirstTrait, SecondTrait {
    override fun foo() {
        super<FirstTrait>.foo()  // delegate to the default implementation of FirstTrait
        super<SecondTrait>.foo() // delegate to the default implementation of SecondTrait
    }

    // function bar() only has a default implementation in one interface and therefore is ok.
}

super mot clé

interface MyInterface {
    fun funcOne() {
        //optional body
        print("Function with default implementation")
    }
}

Si la méthode de l'interface a sa propre implémentation par défaut, nous pouvons utiliser super mot-clé pour y accéder.

super.funcOne()