Dans cet article, vous découvrirez les interfaces et comment les implémenter dans Kotlin à l'aide d'exemples.
Les interfaces Kotlin sont similaires aux interfaces de Java 8. Elles peuvent contenir des définitions de méthodes abstraites ainsi que des implémentations de méthodes non abstraites. Cependant, ils ne peuvent contenir aucun état.
Cela signifie que l'interface peut avoir une propriété, mais elle doit être abstraite ou doit fournir des implémentations d'accesseur.
Lecture recommandée: Kotlin Abstract Class
Les classes abstraites dans Kotlin sont similaires à l'interface avec une différence importante. Il n'est pas obligatoire pour les propriétés d'une classe abstraite d'être abstraites ou de fournir des implémentations d'accesseur.
Comment définir une interface?
Le mot interface- clé est utilisé pour définir les interfaces dans Kotlin. Par exemple,
interface MyInterface (var test: String // propriété abstraite fun foo () // méthode abstraite fun hello () = "Hello there" // méthode avec implémentation par défaut)
Ici,
- une interface MyInterface est créée.
- l'interface a un test de propriété abstraite et une méthode abstraite
foo(). - l'interface a également une méthode non abstraite
hello().
Comment implémenter l'interface?
Voici comment une classe ou un objet peut implémenter l'interface:
interface MyInterface (test val: Int // propriété abstraite fun foo (): String // méthode abstraite (renvoie String) fun hello () (// méthode avec implémentation par défaut // corps (facultatif))) class InterfaceImp: MyInterface (override test val: Int = 25 override fun foo () = "Lol" // autre code)
Ici, une classe InterfaceImp implémente l'interface MyInterface.
La classe remplace les membres abstraits (propriété et foo()méthode de test ) de l'interface.
Exemple: comment fonctionne l'interface?
interface MyInterface ( val test: Int fun foo() : String fun hello() ( println("Hello there, pal!") ) ) class InterfaceImp : MyInterface ( override val test: Int = 25 override fun foo() = "Lol" ) fun main(args: Array) ( val obj = InterfaceImp() println("test = $(obj.test)") print("Calling hello(): ") obj.hello() print("Calling and printing foo(): ") println(obj.foo()) )
Lorsque vous exécutez le programme, la sortie sera:
test = 25 Appel bonjour (): Bonjour, mon pote! Appel et impression de foo (): Lol
Comme mentionné ci-dessus, une interface peut également avoir une propriété qui fournit une implémentation d'accesseur. Par exemple,
interface MyInterface ( // property with implementation val prop: Int get() = 23 ) class InterfaceImp : MyInterface ( // class body ) fun main(args: Array) ( val obj = InterfaceImp() println(obj.prop) )
Lorsque vous exécutez le programme, la sortie sera:
23
Ici, l'accessoire n'est pas abstrait. Cependant, il est valide à l'intérieur de l'interface car il fournit une implémentation pour l'accesseur.
Cependant, vous ne pouvez pas faire quelque chose comme val prop: Int = 23à l'intérieur de l'interface.
Implémentation de deux interfaces ou plus dans une classe
Kotlin n'autorise pas le véritable héritage multiple. Cependant, il est possible d'implémenter deux interfaces ou plus dans une seule classe. Par exemple,
interface A ( fun callMe() ( println("From interface A") ) ) interface B ( fun callMeToo() ( println("From interface B") ) ) // implements two interfaces A and B class Child: A, B fun main(args: Array) ( val obj = Child() obj.callMe() obj.callMeToo() )
Lorsque vous exécutez le programme, la sortie sera:
Depuis l'interface A depuis l'interface B
Résolution des conflits majeurs (interface multiple)
Supposons que deux interfaces (A et B) aient une méthode non abstraite avec le même nom (disons callMe()méthode). Vous avez implémenté ces deux interfaces dans une classe (disons C). Maintenant, si vous appelez la callMe()méthode en utilisant l'objet de la classe C, le compilateur lancera une erreur. Par exemple,
interface A ( fun callMe() ( println("From interface A") ) ) interface B ( fun callMe() ( println("From interface B") ) ) class Child: A, B fun main(args: Array) ( val obj = Child() obj.callMe() )
Voici l'erreur:
Erreur: (14, 1) Kotlin: La classe 'C' doit remplacer public open fun callMe (): Unité définie dans A car elle hérite de plusieurs méthodes d'interface
Pour résoudre ce problème, vous devez fournir votre propre implémentation. Voici comment:
interface A ( fun callMe() ( println("From interface A") ) ) interface B ( fun callMe() ( println("From interface B") ) ) class C: A, B ( override fun callMe() ( super.callMe() super.callMe() ) ) fun main(args: Array) ( val obj = C() obj.callMe() )
Maintenant, lorsque vous exécutez le programme, la sortie sera:
Depuis l'interface A depuis l'interface B
Ici, l'implémentation explicite de la callMe()méthode est fournie dans la classe C.
classe C: A, B (remplace fun callMe () (super.callMe () super .callMe ()))
L'instruction super.callMe()appelle la callMe()méthode de la classe A. De même, appelle la méthode de la classe .super.callMe()callMe()B
