Interfaces en Kotlin

Les interfaces Kotlin sont similaires à Java 8. Le mot-clé interface est utilisé pour définir des interfaces, permettant aux méthodes d'avoir des implémentations par défaut :

interface MyInterface { fun bar() //Non implémenté fun foo() { //Implémenté //Corps de méthode facultatif println("foo") } }

Implémentation des interfaces

Une classe ou un objet peut implémenter une ou plusieurs interfaces.

class Child : MyInterface { override fun bar() { //Corps de méthode } }

Exemple

interface MyInterface { fun bar() fun foo() { //Corps de méthode facultatif println("foo") } } class Child : MyInterface { override fun bar() { //Corps de méthode println("bar") } } fun main(args: Array<String>) { val c = Child() c.foo(); c.bar(); }

Le résultat de sortie est:

foo
bar

Propriétés dans les interfaces

Dans les interfaces, les propriétés ne peuvent être qu'abstraites ; les valeurs d'initialisation ne sont pas autorisées. Les interfaces ne stockent pas de valeurs de propriété. Lors de l'implémentation d'une interface, les propriétés doivent être redéfinies :

interface MyInterface{ var name:String //name propriété, abstract } class MyImpl:MyInterface{ override var name: String = "example" //Redéfinition de la propriété }

Exemple

interface MyInterface { var name:String //name propriété, abstract fun bar() fun foo() { //Corps de méthode facultatif println("foo") } } class Child : MyInterface { override var name: String = "example" //Redéfinition de la propriété override fun bar() { //Corps de méthode println("bar") } } fun main(args: Array<String>) { val c = Child() c.foo(); c.bar(); println(c.name) }

Le résultat de sortie est:

foo
bar
example

Redéfinition de fonction

Lorsque vous implémentez plusieurs interfaces, vous pouvez rencontrer le problème d'héritage de plusieurs implémentations de la même méthode. Par exemple :

Exemple

interface A { fun foo() { print("A") } //Implémenté fun bar() //Non implémenté, pas de corps de méthode, abstrait } interface B { fun foo() { print("B") } //Implémenté fun bar() { print("bar") } //Implémenté } class C : A { override fun bar() { print("bar") } //Redéfinition } class D : A, B { override fun foo() { super<A>.foo() super<B>.foo() } override fun bar() { super<B>.bar() } } fun main(args: Array<String>) { val d = D() d.foo(); d.bar(); }

Le résultat de sortie est:

ABbar

Dans l'exemple, les interfaces A et B définissent toutes deux les méthodes foo() et bar(). Toutes deux implémentent foo(), et B implémente bar(). Comme C est une classe concrète qui implémente A, elle doit redéfinir bar() et implémenter cette méthode abstraite.

Cependant, si nous dérivons D de A et B, nous devons implémenter toutes les méthodes héritées de plusieurs interfaces et spécifier comment D doit les implémenter. Cette règle s'applique à la fois aux méthodes qui héritent d'une seule implémentation (bar()) et aux méthodes qui héritent de plusieurs implémentations (foo()).

Autres extensions