Kotlin : Délégation, Générique

Temps : 45 min.
Diffiulté : *

L'objectif est de mettre en pratique le concept de :

1. Délégation
2. Générique

1. Délégation

Délégation de fonction

Il s'agit de créer une classe, une interface contenant une fonction et d'ajouter la délégation sur l'interface.

1. Dans le package agua, créez un nouveau package crab.
2. Dans le package agua.crab, créez un nouveau fichier HermitAndCrab.kt
3. Créez une nouvelle interface CrabAction :

  
  interface CrabAction {
      fun pinch()
  }
  
  

4. Créez une classe Crab, elle implémente l'interface CrabAction :

  
  class Crab : CrabAction {
      override fun pinch() = println("_-<>  pinch <>-_")
  }
  
  

5. Ajouter une classe PrintingCrabAction, elle implémente CrabAction :

  
  class PrintingCrabAction(val crabAction: String) : CrabAction {
    override fun pinch() {
        println(crabAction)
    }
  }
  
  

6. Ajouter la délégation d'interface pour CrabAction :

  
  class Crab : CrabAction by PrintingCrabAction("_-<>  pinch <>-_")
  
  

7. Créez une fontion playWithCrab() pour tester (faites pincer le crabe), appellez là dans un main
8. Exécutez votre programme

Délégation de propriété avec Singleton

Il s'agit de créer une classe, une interface avec propriété, une classe singleton et d'ajouter la délégation sur l'interface via le singleton.

1. Créez une nouvelle interface GastropodShell :

  
  interface GastropodShell {
      val shell: String
  }
  
  

2. Créez une classe HermitCrab, elle implémente l'interface GastropodShell :

  
  class HermitCrab : GastropodShell {
    override val shell = "SHELL"
  }
  
  

3. Ajoutez dans playWithCrab() une instance de HermitCrab pour tester (affichez la carapace du bernard l'hermite), exécutez le main
4. Créez une classe singleton Shell, elle implémente l'interface GastropodShell :

  
  object Shell : GastropodShell {
    override val shell = "((.))"
  }
  
  

5. Ajouter la délégation d'interface pour GastropodShell :

  
  class HermitCrab : GastropodShell by Shell
  
  

6. Exécutez votre programme

2. Générique

Il s'agit de créer des listes d'objet afin de mettre en pratique le concept de générique. Aussi il s'agit de créer des classes d'héritage pour mettre en évidence le principe de covariance et contravariance.

Principe de Covariance

1. Dans le package agua, créez un nouveau package beach.
2. Dans le package agua.beach, créez un nouveau fichier BeachEquipment.kt
3. Créez une nouvelle classe d'héritage BeachEquipment :

    
    open class BeachEquipment(val name: String) {
        fun removeSand() {}
    }
    
    

4. Créez deux classes de données Towel et Umbrella, des sous classes de BeachEquipment :

    
    data class Towel(val towelName: String) : BeachEquipment(towelName)
    data class Umbrella(val umbrellaName: String) : BeachEquipment(umbrellaName)
    
    

5. Dans une fonction main, créez une liste de Umbrella, de Towel et de BeachEquipment :

    
    fun main() {
      val umbrellaList = listOf(Umbrella("Macha umbrella"), Umbrella("Red umbrella"), Umbrella("White Umbrella"))
      val towelList = listOf(Towel("Macha Towel"), Towel("Gugus towel"))
      val beachParty = umbrellaList + towelList
      print(beachParty)
    }
    
    

6. Créez une fonction removeSand() prenant en paramètre une liste de BeachEquipment, elle s'applique à la classe parent et donc aux sous classes de la classe parent, selon le principe de covariance :

    
    fun removeSand(equipmentList: List<BeachEquipment>) {
      equipmentList.forEach {
          it.removeSand()
          println(it.name + " cleaned !")
      }
    }
    
    

7. Appelez cette fonction dans le main, exécutez

Principe de Contravariance

1. Dans BeachEquipment.kt, créez un comparateur de BeachEquipment :

    
    val compareByNames = Comparator { a: BeachEquipment, b: BeachEquipment ->
      a.name.length - b.name.length
    }
    
    

2. Dans le main triez les éléments de beachParty via ce comparateur :

    
    beachParty.sortedWith(compareByNames).forEach(::println)
    
    

3. Exécutez, observez le résultat

Finalement, le code Kotlin peut être épuré avec la délégation de :

• fonction
• propriété

• covariance
• contravariance

Références

developer.android.com: Using Classes and Objects in Kotlin
medium.com: Kotlin Covariance and Contravariance