Les objets compagnons dans kotlin

En Java lorsqu’on crée une fonction membre statique ou une variable membre statique c’est pour l’appeler sans créer une instance de la classe dans laquelle elle est déclarée.

En Java une fonction membre statique ou une variable membre statique est lié à une classe et non a une instance de la classe .

Effet,elle est déclarée avec le mot clé static .Contrairement à java , les variables de classe ou fonctions membres déclarées avec le mot clé static n’existe pas dans kotlin.

Kotlin utilise les objets compagnons(companion object) déclarés à l’intérieur d’une classe pour créer une variable membre ou une fonction membre qui n’est pas liée à une instance de classe.

Donc pour appeler une fonction membre ou une variable membre sans une instance d’une classe , vous devez déclarer ces membres à l ‘intérieur d’un objet compagnon.

Voici comment déclarer un objet compagnon( avec des variables membres et fonction membres) à l’intérieur d’une classe

class Personne{
  companion object Factory{
     fun create(){
      print("Personne créée")
     }
  }
}

Vous pouvez ensuite appeler la fonction create comme suit

 val personne = Personne.create()
 print(personne)

Résultat: Personne créée

Vous devez constater que l’appelle de la fonction create est similaire à l’appelle d’une fonction statique en Java.

Vous pouvez même omettre le nom de l’objet compagnon.Dans ce cas, le nom Companion sera utilisé.

Voici un exemple.Créez d’abord cet objet compagnon qui n’est pas nommé

class Personne{
  companion object {
     fun create()="Personne créée"
  }
}

Ensuit pouvez appeler la méthode create de deux manières comme suit.

fun main(){
  val personne = Personne.create() //Méthode 1
  val personne2=Personne.Companion.create() //Méthode 2
  print(personne)

}

Résultat: Personne créée

Le objets compagnon en interne

Notez que même si les membres des objets compagnons ressemble à des membres statiques comme dans d’autres langages comme Java, ceux-ci sont toujours au moment de l’exécution des membres d’ instance d’objets réels.

Ainsi, un objet compagnon peut par exemple implémenter une interface.Si vous ne savez pas comment créer une interface en Kotlin, vous pouvez lire ce tutoriel sur les interfaces.

class Personne{
  companion object:Factory {
   override fun create() ="Personne créée"
  }
}

Vous pouvez ensuite appeler la fonction membre create comme suit

fun main(){
  val personne = Personne.create()
  print(personne)
}

Interopérabilité avec Java(créer des variables et fonctions membres statiques en Java).

Vous savez probablement déjà que Kotlin est interopérable avec Java.Pour appeler des variables et fonctions membres statique écrit dans kotlin dans du code Java,vous devez déclarer ces membres dans un objet compagnon qui est lui aussi déclaré dans une classe dans kotlin.

Puisque en interne les membres d’un objet compagnon sont au moment de l’exécution des membres d’instance d’objet, vous ne pouvez pas par exemple directement appeler dans du code Java la fonction membre create comme une fonction membre statique comme vous le faites dans du code Kotlin . Voir l’exemple

Créez un objet compagnon comme suit

class Personne{
  companion object  {
     fun create() ="Personne créée"
  }
}

Vous ne pouvez pas ensuite appelez la fonction create en Java comme suit

Personne.create()//Ne fonctionne pas en java

En Java ,la fonction membre create n’est pas reconnu comme une méthode statique. Donc le compilateur vous signalera une erreur.

Il existe plusieurs manière d’appeler la fonction create comme méthode statique en Java

Premièrement, si vous n’avez pas nommé l’objet compagnon,vous pouvez appeler le fonction create avec le nom Companion comme suit.

Personne.Companion.create() //Marche

Deuxièmement, si vous avez nommé l’objet compagnon, vous pouvez aussi appeler le fonction create .

Créez d’abord cet objet compagnon nommé

class Personne{
  companion object Factory { //Objet Factory
   fun  create()="Personne créée"

  }
}

L’objet compagnon est nommé Factory

Vous pouvez ensuite appeler la fonction create comme suit

 Personne.Factory.create() //Marche

Troisièmement, les variables membres déclarer dans des objets compagnons ont chacun un champs auto généré (backing field) dans l’objet compagnon.Par défauts ces champs sont privés mais vous pouvez les exposer avec l’annotation @JvmField .Ces membres devient alors comme des variables statiques réelles.Voir l’exemple suivant

Créez d’abord l’objet compagnon suivant

class Personne{
  companion object  {
     @JvmField
     val COUNT_PERSONNE: Int = 1
  }
}

Vous devez constater que la variable membre dans l’objet compagnon est annotée.

Vous pouvez donc appeler la variable membre COUNT_PERSONNE comme variable statique en Java comme suit

Personne.COUNT_PERSONNE

ET Enfin, les fonctions membres déclarées dans un objet compagnon peuvent être générées comme des fonctions membres statique avec l’annotation @JvmStatic.

Créez l’objet compagnon suivant

class Personne{
  companion object  {
   @JvmStatic  fun  create()="Personne créée"
    fun create2NonStatic()="Personne creéé 2"
  }
}

Vous pouvez ensuite appeler ces fonctions membres en Java comme suit.

  Personne.create() //Marche
  Personne.create2NonStatic()//Ne marche pas dans Java
  Personne.Companion.create() //Marche
  Personne.Companion.create() //marche

Dans l’exemple précédent, si l’objet compagnon étais nommé vous devriez remplacer le nom Companion par le nom de l’objet.

Conclusion

Voila, nous sommes à la fin de ce tutoriel dans lequel vous avez appris à créer des objets compagnons.J’espère que ce tutoriel vous aidera.A bientôt pour un nouveau tutoriel.

Autres ressources

https://kotlinlang.org/docs/reference/object-declarations.html