Kotlin : Classe, Propriété, Fonction

Temps : 45, 20, 30, 15 min.
Difficulté : ***

Cette partie aborde les fondamentaux de la POO avec le langage Kotlin, selon les points suivants :

1. Déclaration de classe, constructeurs, attributs, fonctions
2. Héritage
3. Classe Abstraite et Interface
4. Classe Data et Enum

1. Déclaration de classe, constructeurs, attributs, fonctions

Package en Kotlin

En programmation, les packages servent à garder le code organisé.

1. Ouvrez IntelliJ IDE, créez un nouveau projet New Project
2. Nommez votre projet Beach, attention à selectionner IntelliJ pour Build System
3. Sélectionnez New > Package, depuis le clique droit de src > main > kotlin, nommez-le agua

Déclaration de classe

En Kotlin, une classe est défini avec le mot clé class.
Note : Le nom d'une classe commence par une majuscule.

1. Sélectionnez New > Kotlin File / Class, depuis le clique droit du package agua
2. Sous Kind, sélectionnez Class et nommez-là Boat
3. Dans la classe Boat, définissez et initialisez les variables length, width, floor

    
    package agua

    class Boat {
        var length: Int = 10
        var width: Int = 5
        var floor: Int = 1
    }
    
    

Note : Il n'y a pas besoin d'écrire les getters et setters, ils sont implicites. De plus, par défaut tout est publique, d'où l'absence du mot clé public.

Fonction main

En programmation, la fonction main() est le point d'entré d'un programme.
En Kotlin, une fonction est déclaré avec le mot clé fun.

1. Sélectionnez New > Kotlin File / Class, depuis le clique droit du package agua
2. Sous Kind, sélectionnez File et nommez-le Main.kt
3. Définissez la fonction buildBoat(), elle créé une instance de Boat

    
    package agua

    fun buildBoat() {
        val myBoat = Boat()
    }
    
    

Note : Pour créer une instance, référencez la classe comme s'il s'agissait d'une fonction (Boat()) Cela appelle le constructeur de la classe et crée une instance de cette dernière, similaire à l'utilisation du mot clé new dans d'autres langages.


4. Définissez une fonction main(), elle appelle buildBoat()

    
    package agua
    ...
    fun main() {
        buildBoat()
    }
    
    

5. Exécutez la fonction main() (Control + Shift + R)

Fonction membre

Une fonction membre, member function, ou méthode est une fonction pouvant s'appliquer sur un objet spécifique.

1. Dans la classe Boat, ajoutez une méthode d'affichage :

    
    fun printSize() {
        println("Length: $length m " +
                "Width: $width m " +
                "Floor: $floor m ")
    }
    
    

2. Dans le fichier Main.kt, depuis buildBoat(), appelez la méthode printSize() sur myBoat

    
    fun buildBoat() {
        val myBoat = Boat()
        myBoat.printSize()
    }
    
    

3. Exécutez, observez le résultat dans la console
4. Dans buildBoat(), modifiez un des attributs de myBoat, puis affichez le changement

    
    fun buildBoat() {
        val myBoat = Boat()
        myBoat.printSize
        // modification de la hauteur
        myBoat.floor = 60
        myBoat.printSize()
    }
    
    

5. Exécutez, observez le résultat attendu

Constructeur

En Kotlin, il y a deux types de constructeurs :

• constructeur implicite (primaire) : placé dans l'entête de la classe
• constructeur explicite (secondaire) : déclaré via le mot clé constructor

1. Dans la classe Boat, changez l'entête de classe pour inclure un constructeur primaire avec des valeurs par défaut, modifiez les propriétés en conséquence :

    
    class Boat(length: Int = 10, width: Int = 5, floor: Int = 1) {
       // Dimensions en cm
       var length: Int = length
       var width: Int = width
       var floor: Int = floor
    ...
    }
    
    

2. Il est possible d'épurer ce code en kotlin en définissant les propriétés directement dans le constructeur :

    
    class Boat(var length: Int = 10, var width: Int = 5, var floor: Int = 1) {
    ...
    }
    
    

3. Testez le nommage des paramètres dans le fichier Main.kt, buildBoat(), en créant différentes instances de bateau :

    
    val Boat1 = Boat()
    boat1.printSize()
    // default floor and length
    val Boat2 = Boat(width = 25)
    boat2.printSize()
    // default width
    val boat3 = Boat(floor = 35, length = 110)
    boat3.printSize()
    // everything custom
    val boat4 = Boat(width = 25, floor = 35, length = 110)
    boat4.printSize()
    
    

4. Exécutez la fonction main() (Control + Shift + R), observez le résultat attendu

Bloc d'initialisation

En Kotlin, il existe le bloc d'initialisation, init.
Il permet de placer du code d'initialisation lorsque le constructeur en a besoin.

1. Dans la classe Boat, placez un bloc init :

    
    class Boat(var length: Int = 10, var width: Int = 5, var floor: Int = 1) {
      init {
          println("Boat in construction")
      }
    }
    
    

2. Exécutez le programme de nouveau et observez le résultat

Constructeur secondaire

En Kotlin, il est possible de déclarer les deux types de constructeur primaire et secondaire dans la même classe. Cela permet de faire de la surcharge de constructeur, constructor overloading, avec des arguments différents.
Lorsqu'il y a plusieurs constructeur, il s'appelle les uns des autres avec le mot clé this (et des arguments null, cf. Challenge : Créer une vue personnalisée).
Note : L'ordre d'exécution des constructeurs et bloc d'initialisation est

1. primary constructor
2. init block
3. secondary constructor

1. Dans la classe Boat, ajoutez un constructeur secondaire :

    
    constructor(numberOfPeople: Int) : this() {
    // nombre de personne pouvant être accueillie
    val area = numberOfPeople * 2
    }
    
    

2. Dans ce constructeur secondaire, ajoutez la modification des attributs :

    
    // la largueur du bateau est fixe, la hauteur est flexible,
    // il s'agit de calculer le nombre d'étage nécessaire pour le bien être des passagers
    floor = area / (length * width)
    
    

3. Dans le fichier Main.kt, appellez le constructeur ainsi créé depuis buildBoat() :

    
    fun buildBoat() {
    val boat6 = Boat(numberOfFish = 29)
    boat6.printSize()
    println("Area: ${boat6.width * boat6.length * boat6.floor} m2")
    }
    
    

4. Exécutez le programme de nouveau et observez le résultat

Accesseur et mutateur

En Kotlin, l'accesseur et le mutateur d'une propriété est automatiquement créés. Cependant, il est possible de créer un mutateur, ou un accesseur, personnalisé pour chaque propriété.

1. Dans la classe Boat, définissez une propriété personnalisée :

    
    // la superficie se calcule à partir des autres propriétés longueur et largueur
    val area: Int
      get() = length * width * floor
    
    

2. Enlevez le bloc init affichant la superficie
3. Enlevez le code lié à l'affichage, dans la fonction buildBoat()
4. Dans la méthode printSize(), ajoutez l'affichage de la superficie

    
    fun printSize() {
      println("Length: $length m " +
              "Width: $width m " +
              "Floor: $floor ")
      println("Area: $area m2")
    }
    
    

5. Exécutez le programme de nouveau et observez le résultat attendu

1. Dans la classe Boat, changez la propriété area immuable en mutable var
2. Définissez le mutateur de cette propriété :

    
    var area: Int
      get() = length * width * floor
      set(value) {
            floor = (value) / (length * width)
        }
    
    

3. Dans buildBoat(), ajoutez la modification de la superficie

    
    fun buildBoat() {
      val boat6 = Boat(numberOfPeople = 29)
      boat6.printSize()
      boat6.area = 70
      boat6.printSize()
    }
    
    

4. Exécutez le programme de nouveau et observez le résultat

Visibilité des membres

En Kotlin, les classes, les objets, les interface, les constructeurs, les fonctions, les propriétés et leurs accesseurs peuvent avoir des modificateurs de visibilité.
Par défaut, tout est publique, public.

2. Héritage

En Kotlin, l'héritage n'est pas automatique, une classe mère doit être déclaré open, de façon a lui permettre d'être une super classe.
De même les propriétés et membre doivent être déclaré open.

Classe open

L'objectif est de transformer le bateau en une classe mère.

1. Dans la classe boat, changez la signature de façon a déclaré la classe open
2. Déclarez également toutes les propriétés comme open

    
    open var area: Int
        get() = length * width * floor
        set(value) {
            floor = value / (length * width)
        }
    
    

3. Ajoutez une propriété pour le matériau du bateau

    
    open val material = "wood"
    
    

4. Ajoutez une propriété pour l'espace réservé aux voyageurs

    
    open var areaForPeople: Double = 0.0
        get() = area * 0.5
    
    

5. Modifiez la méthode d'affichage pour rendre compte des nouvelles propriétés

    
    fun printSize() {
        println("The boat is in $material (material)")
        println("Length: $length m " +
                "Width: $width m " +
                "Floor: $floor ")
        println("Area: $area m2; Area for People: $areaForPeople (${areaForPeople / area * 100.0} % full)")
    }
    
    

6. Dans buildBoat(), créez une instance de bateau comme suit :

    
    fun buildBoat() {
        val boat6 = Boat(length = 25, width = 25, floor = 40)
        boat6.printSize()
    }
    
    

7. Exécutez le programme de nouveau et observez le résultat

Sous Classe

Il s'agit de créer une sous classe ou classe fille. Contexte : Le bateau, pouvant également représenter un navire, est trop général, nous souhaitons à présent créer un voilier.

1. Dans le fichier de la classe Boat, à la suite de la classe Boat, déclarez une classe SailBoat

    
    class SailBoat(override var length: Int, override var width: Int) :
        Boat(length = length, width = width, floor = 2)
    
    

2. Surchargez, override, la propriété de la superficie, par rapport à la forme du voilier :

    
    override var area: Int
        // area = width * length / 3
        get() = length * width / 3 * floor
        set(value) {
            floor = value / length / width
        }
    
    

3. Surchargez la propriété de l'espace réservé aux voyageurs

    
    override var areaForPeople = area * 0.25
    
    

4. Surchargez la propriété du matériau

    
    override val material = "wood"
    
    

5. Le code complet est :

    
package agua

class SailBoat(override var length: Int, override var width: Int) :
        Boat(length = length, width = width, floor = 2) {
    override var area: Int
        // area = width * length / 3
        get() = length * width / 3 * floor
        set(value) {
            floor = value / length / width
        }

    override var areaForPeople = area * 0.25

    override val material = "wood"
}
    
    

6. Dans buildBoat(), créez une instance de voilier :

    
    fun buildBoat() {
      val myBoat = Boat(width = 25, length = 25, floor = 40)
      myBoat.printSize()
      val sail = SailBoat(width = 25, length = 25)
      sail.printSize()
    }
    
    

7. Exécutez le programme de nouveau et observez le résultat

3. Classe Abstraite et Interface

Dans certain cas, nous souhaitons définir des comportements identiques pour des propriétés ou des classes.
Par exemple, nous allons créer :

• une classe abstraite pour les propriétés communes des poissons.
• une interface pour définir les comportements communs de tous les poissons

Classe abstraite

Une classe abstraite est partiellement définie. C'est de la responsabilité de la sous classe de définir les méthodes et propriétés.
Par défaut une classe abstract est open, il n'y a pas besoin de le spécifier.
Elle peut avoir des propriétés et des méthodes abstraite, dans ce cas la sous classe est en charge de les définir.
Elle peut aussi définir un constructeur commun pour toute les sous classes.

1. Dans le package agua, créez un nouveau fichier Fish.kt
2. Créez une classe Fish déclarez là comme abstraite :

  
  package agua

  abstract class Fish
  
  

3. Ajoutez une propriété abstraite dans la classe :

  
  abstract val color: String
  
  

4. Dans le même fichier, créez deux sous classes de Fish : Shark et Plecostomus
5. Comme la propriété color est abstraite, Shark et Plecostomus doivent la définir

  
  class Shark: Fish() {
      override val color = "grey"
  }

  class Plecostomus: Fish() {
      override val color = "gold"
  }
  
  

6. Dans le fichier Main.kt, créez une fonction makeFish() afin d'y instancier des poissons

  
  fun makeFish() {
      val shark = Shark()
      val pleco = Plecostomus()

      println("Shark: ${shark.color}")
      println("Plecostomus: ${pleco.color}")
  }
  
  

7. Appelez makeFish() dans le main, exécutez le programme et observez le résultat

Interface

1. Dans le fichier Fish.kt, créez une interface avec une méthode

    
    interface FishAction  {
        fun eat()
    }
    
    

2. Ajoutez l'interface FishAction aux deux sous classes
3. Elles doivent alors implémenter la méthode eat() :

    
    class Shark: Fish(), FishAction {
      override val color = "grey"
      override fun eat() {
          println("hunt and eat fish")
      }
  }

  class Plecostomus: Fish(), FishAction {
      override val color = "gold"
      override fun eat() {
          println("eat algae")
      }
  }
    
    

4. Dans la fonction makeFish(), faites manger les poissons

    
    fun makeFish() {
      val shark = Shark()
      val pleco = Plecostomus()
      println("Shark: ${shark.color}")
      shark.eat()
      println("Plecostomus: ${pleco.color}")
      pleco.eat()
    }
    
    

5. Exécutez le programme de nouveau et observez le résultat

Classe abstraite Vs Interface

L'astuce est d'utiliser une classe abstraite tant qu'il n'est pas possible de compléter la classe.

1. Dans le fichier Fish.kt, modifiez la classe abstraite pour générer une implémentation générale pour le comportement du poisson

    
    abstract class Fish : FishAction {
       abstract val color: String
       override fun eat() = println("yum")
    }
    
    

2. Créez un poisson rouge, une sous classe de cette classe abstraite

    
    class RedFish : Fish() {
      override val color = "red"
    }
    
    

3. Dans la fonction makeFish() testez le poisson rouge

    
    fun makeFish() {
      val fish = RedFish()
      println("Fish: ${fish.color}")
      fish.eat()
    }
    
    

4. Exécutez le programme de nouveau et observez le résultat

4. Classe Data et Enum

En Kotlin, les qualificatifs de classe les plus connus sont :

• data : représente une donnée
• nested : une classe dans la classe (static class in Java)
• inner : visibilité des membres élargie (ajoute une référence à une classe extérieur)
• enum : représente une énumération
• sealed : restreint la hiérarchie de la classe (le nombre de sous classe est fixe, elles sont placées dans le même fichier)

Classe de donnée

La classe de donnée, ou data class, est une bonne pratique afin d'indiquer la simplicité de l'objet.
Déclarée avec le mot clé data, la classe a accès a des fonctions générées automatiquement, tel que la fonction equals(), hascode(), toString()...

1. Créez un nouveau package dans agua, nommez-le deco
2. Dans ce package, créez une nouvelle classe, de donnée, Decoration :

    
    data class Decoration(val rocks: String)
    
    

3. Dans ce fichier Decoration.kt, à l'extérieur de la classe, ajoutez une fonction makeDecorations() pour afficher des instances de la classe de donnée

    
    fun makeDecorations() {
      val decoration1 = Decoration("granite")
      println(decoration1)
    }
    
    

4. Ajoutez une fonction main() pour tester, exécutez
5. Ajoutez deux autres instances crystal dans makeDecorations()

    
    fun makeDecorations() {
      val decoration1 = Decoration("granite")
      val d2 = Decoration("crystal")
      val d3 = Decoration("crystal")

      println("$decoration1 $d2 $d3")
    }
    
    

6. Exécutez le programme
7. Dans makeDecorations(), testez l'égalité des instances :

    
    println("deco 1 et deco 2 : ${decoration1.equals(d2)}")
    println("deco 2 et deco 3 (equals): ${d2.equals(d3)}")
    println("deco 2 et deco 3 (==): ${d2 == d3}")
    println("deco 2 et deco 3 (===): ${d2 === d3}")
    
    

Note : == et equals c'est pareil (operator overloading), === correspond à l'égalité sur la référence de l'objet

Classe d'énumération

La classe d'énumération, ou enum class, est une bonne pratique afin d'énumerer des valeurs.
Cela dit, il est plus courant d'utiliser le singleton (companion object).

1. Dans le fichier Decoration.kt, déclarez une classe d'énumération :

  
  enum class Direction(val degrees: Int) {
      NORTH(0), SOUTH(180), EAST(90), WEST(270)
  }
  
  

2. Dans le main testez :

  
  println(Direction.EAST.name)
  println(Direction.EAST.ordinal)
  println(Direction.EAST.degrees)
  
  

3. Exécutez

Finalement, Kotlin est un langage de programmation fonctionnelle et orientée objet par rapport à :

• la déclaration de classe class, open, abstract, interface, data, enum
• la déclaration de propriété, méthode, leur visibilité
• la déclaration de variable, fonction
• les constructeurs primary, secondary constructor et le bloc init
• la définition d'accesseur, mutateur

Référence :

developer.android.com: Using Classes and Objects in Kotlin