Les interfaces dans kotlin


Comme les classes abstraites, les interfaces ne peuvent pas être instanciées mais peuvent contenir des déclarations de méthodes abstraites et de méthodes implémentées.

Ce qui rend une interface différente d’une classe abstraite est que, une interface ne peut pas conserver d’état, c’est à dire que vous ne pouvez pas déclarer un propriété et l’affecter une valeur dans une interface. .Les propriétés sont donc abstraites ou fournissent une implémentation des accesseurs.

Table des matières

Les Interfaces

Un interface est définie avec le mot clé interface suivit du nom de l’interface

interface MyInterface{
    fun methode1()
    fun methode2(){
        println("Méthode 1")
    }
}

Dans cet exemple, l’interface MyInterface possède une méthode abstraite et une méthode implémentée

Implémenter une interface

Une classe ou un objet peut implémenter une interface .Les méthodes implémentées dans la classe dérivée doivent être marquées override.

interface MyInterface{
    fun methode1()
    fun methode2(){
        println("Méthode 1")
    }
}
class MyClasse:MyInterface{

    override fun methode1() {
        
    }
}

Les propriétés dans une interface.

Vous pouvez déclarer des propriétés dans une interface.Une propriété déclarée dans une interface peut être abstraite ou fournir l’implémentation de ses accesseurs.

Il faut noter que vous n’avez pas besoin de marquer la propriété avec le mot clé abstraite pour la rendre abstraite.Dès que vous déclarer la propriété dans l’interface, elle est par défaut abstraite.

Puisque qu’une propriété abstraite n’est pas initialisée dans une interface,la propriété ne possède pas de champs auto généré(backing field) dont l’identificateur est field.

Les accesseurs n’ont donc pas accès au champ auto généré.Le backing field(field) est l’identificateur utilisé comme référence à une propriété pour accéder ou modifier cette propriété dans les accesseurs de la propriété.

Voici un exemple qui montre comment déclarer une propriété abstraite dans une interface.

interface MyInterface{
   val propriete1: String

    fun methode1(){
       println(propriete1) 
    }
}

class MyClasse:MyInterface{
    override val propriete1: String="Propriété"
}

Cet exemple illustre cette fois-ci comment déclarer une propriété et définir ses accesseurs dans une interface.

fun main(){
  val myClasse=MyClasse()
  myClasse.methode1()

}

interface MyInterface{
   val propriete1: String
     get() = "Propriété"

    fun methode1(){
       println(propriete1)
    }
}

class MyClasse:MyInterface{

}

Résultat:Propriété

Dans cet exemple la classe dérivée ne redéfinie pas la propriété déclarée dans l’interface puisque l’accesseur fourni déjà la valeur de la variable

L’héritage d’interface

Une interface peut dériver d’une autre interface, et peut implémenter les membres de l’interface de base.Chaque interface peut aussi déclarer ses nouvelles propriétés et fonctions membres.

Prenons l’exemple suivant

interface Perimetre{
 var perimetre: Int
}
interface Calcul:Perimetre{
  val largeur: Int
  val longueur: Int
  override var perimetre: Int get() = (longueur + largeur) * 2
  set(value) {}

}

Dans cette exemple, l’interface Calcul qui dépend de l’interface Perimetre par la propriété perimetre redéfinie la propriété perimetre.

Puisque la propriété perimetre est mutable,vous devez fournir les accesseurs(getter et setter) de cette propriété dans l’interface dérivée.

Comme les propriétés ne peuvent pas être initialisées dans une interface, elle ne possède donc pas de champ auto généré(backing field), le setter est quand même défini mais n’affect aucune valeur(un setter vide).

Le getter quand à lui renvoie une valeur qui ne dépend pas du champ auto généré (backing field) .

Vous pouvez ne pas définir de setter, il suffit juste de déclarer la propriété perimetre comme immuable (une propriété marquée val ) comme suit

interface Perimetre{
 val perimetre: Int
}
interface Calcul:Perimetre{
  val largeur: Int
  val longueur: Int
  override val perimetre: Int get() = (longueur + largeur) * 2
  
}

Toute classe qui hérite de ces interfaces devra fournir une implémentation des propriétés et méthodes qui n’ont pas encore été défini dans les interfaces. .

Prenons l’exemple suivant

fun main(){
  val rectangle= Rectangle(200,200)
  val perimetre = rectangle.perimetre
  println("Le périmètre du rectangle est $perimetre")
}

interface Perimetre{
 val perimetre: Int
}
interface Calcul:Perimetre{
  val largeur: Int
  val longueur: Int
  override val perimetre: Int get() = (longueur + largeur) * 2
}

class Rectangle(override val largeur: Int, override val longueur: Int):Calcul{

}

Résoudre les conflits de redéfinition.

Quand vous déclarer plusieurs types à une classe ou quand une classe dérive de plusieurs interfaces, si les interfaces de base déclare une même méthode, vous devez implémenter cette méthode dans la classe dérivée même s’il y a une interface qui implémente cette méthode

Voici un exemple de classe qui dérive de plusieurs interfaces.

interface  A{
  fun methode1(){
      println("A")
  }
  fun methode2()
}
interface  B{
 fun methode1(){
    println("B")
 }
 fun methode2() {
     println("Méthode 2")
 }

}
class C:A,B{

    override fun methode1() {
        super<A>.methode1()
        super<B>.methode1()
    }
    override fun methode2() {
        super.methode2()
    }
}

Dans cette exemple, la méthode methode1,est implémentée dans les deux interfaces donc elle doit être définie dans la classe dérivée à cause de l’héritage multiple.Quand à la méthode méthode methode2,elle n’est pas implémentée dan l’interface A.

Conclusion

Voila, dans ce tutoriel vous avez appris à créer des interfaces dans kotlin. J’espère que ce tutoriel vous aidera à commencer à utiliser les interfaces dans votre projet.A bientôt pour un nouveau tutoriel.

Autres ressources

https://kotlinlang.org/docs/reference/interfaces.html


Laisser un commentaire

Résoudre : *
6 ⁄ 1 =


%d