Les classes abstraites

Une classe abstraite est une classe marquée avec le mot clé abstract et qui ne peut pas être instanciée.Grace aux classes abstraites vous pouvez créer des classes dérivées ayant un comportement commun.

Une classe abstraite remplie les conditions suivantes:

• 1- Une classe abstraite est marquée avec le mot clé abstract
• 2- Une classe ne peut pas être instanciée
• 3- Une classe abstraite peut contenir des fonctions membres abstraite(non implémentées)ou implémentées
• 4- Une classe abstraite peut contenir des propriétés abstraites
• 5- Enfin une classe abstraite définit un comportement commun à toutes ses classes dérivée

Les classes abstraites dans Kotlin

Dans Kotlin une classe abstraite est marquée avec le mot clé abstract.

Voici un exemple de déclaration d’une classe abstraite dans kotlin

abstract  class Personne

Par défaut les fonctions membres et les propriétés sont non abstraites dans une classe abstraite.Vous devez les marquer avec le mot clés abstract pour les rendre abstraites.

Voici un exemple qui illustre comment rendre certaines fonctions membres et propriétés abstraites.

abstract  class Forme(var longueur: Int, var largeur: Int ){

 abstract var formeType: String
 abstract  fun surface():Int
 abstract  fun perimetre():Int
  fun affiche(){
  println("Dimension: ($longueur,$largeur)")
 }

}

Les dérivées de classe abstraite

Toutes les classes dérivées d’une classe abstraite doivent obligatoirement implémenter( redéfinir) toutes les fonctions membres et propriétés de la classe abstraite à moins ces classes dérivées soient elles même abstraites.

Nous avons aussi déjà dis dans le tutoriel sur l’héritage que par défaut, une classe est marquée final par défaut .Et que vous devez donc maqué une classe par open pour permettre qu’elle soit héritable.

Cependant, vous n’avez pas besoin de marquer une classe abstraite open pour qu’elle soit héritable juste parce qu’ une classe abstraite est déjà open par défaut .

Voici un exemple qui illustre comment créer une dérivée d’une classe abstraite

abstract  class Forme(var longueur: Int, var largeur: Int ){

 abstract var formeType: String
 abstract  fun surface():Int
 abstract  fun perimetre():Int
  fun affiche(){
  println("Dimension: ($longueur,$largeur)")
 }

}
class Rectangle( valueX: Int, valueY: Int ):Forme(valueX,valueY){

    override var formeType: String= "Rectangle"

    override fun perimetre(): Int {
    return (longueur+largeur) * 2
    }
    override fun surface(): Int {
    return longueur * largeur
    }

}

Si vous souhaitez redéfinir une fonction membre non abstraite d’une classe abstraite. Vous devez la marquée open

abstract  class Forme(var longueur: Int, var largeur: Int ){

 abstract var formeType: String
 abstract  fun surface():Int
 abstract  fun perimetre():Int
  open fun affiche(){
  println("Dimension: ($longueur,$largeur)")
 }

}
class Rectangle( valueX: Int, valueY: Int ):Forme(valueX,valueY){

    override var formeType: String= "Rectangle"

    override fun perimetre(): Int {
    return (longueur+largeur) * 2
    }
    override fun surface(): Int {
    return longueur * largeur
    }
    override fun affiche() {
        super.affiche()
    }
}

Dans cet exemple la fonction membre affiche est marquée open dans la classe Forme pour permettre à ce qu’elle puisse être redéfinie dans la classe dérivée Rectangle.

Voici un exemple d’utilisation de la classe Rectangle.

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

abstract  class Forme(var longueur: Int, var largeur: Int ){

 abstract var formeType: String
 abstract  fun surface():Int
 abstract  fun perimetre():Int
  open fun affiche(){
  println("Dimension: ($longueur,$largeur)")
 }

}
class Rectangle( valueX: Int, valueY: Int ):Forme(valueX,valueY){

    override var formeType: String= "Rectangle"

    override fun perimetre(): Int {
    return (longueur+largeur) * 2
    }
    override fun surface(): Int {
    return longueur * largeur
    }
    override fun affiche() {
      println("Il s'agit d'un $formeType de dimension ($longueur,$largeur)")
    }
}

Résultat:
Il s’agit d’un Rectangle de dimension (200,200)
Le périmètre du rectange est 800
La surface du rectange est 40000

Conclusion

Voila, dans ce tutoriel vous avez appris commet déclarer et utiliser une classe abstraite avec des fonctions membres, propriétés abstraites et non abstraites.J’espère que ce tutoriel vous aidera.A bientôt pour un nouveau tutoriel.

Autres Ressources

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