Les mots clés lateinit et lazy dans kotlin

Partager

Kotlin est un langage de programmation robuste en se sens où il vous évite l’une des erreurs des classes la plus commune tel que NullPointerException.

A cet effet, une variable déclarée dans kotlin est non nul par défaut.Et lorsque vous déclarez une nouvelle variable dans kotin ,vous devez toujours l’initialiser.

Vous pouvez initialiser la variable soit en définissant une valeur par défaut de son type, soit en définissant sa valeur à nul. Par contre , pour initialiser la variable à une valeur nul vous devez explicitement dire à kotlin que la variable peut prendre une valeur nul.

Qu’en est-il alors de si l’on souhaite créer un objet et ne pas initialiser certaines de ses variables membres lors de leurs déclarations comme on sait le faire en Java.

Ou qu’en est-il de si vous souhaitez initialiser une variable plus tard via une injection de dépendance . A cet effet, kotlin nous permet de retarder l’initialisation d’une variable de plusieurs manières .

.

Table des matières

lateinit

Pour retarder l’initialisation d’une variable non nul, vous pouvez utilise le mot clé lateinit lors de la déclaration de la variable comme suit.

fun main(){
 val personn =Personn("VIGAN","Noé ")
}
data class Personn(val nom: String,val prenom: String){
  lateinit var leg: Leg//Initialisation retardée
  init {
      leg=Leg(2)
  }
  
  fun affiche()="Le nom de pieds de $nom $prenom est ${leg.nbleg}"
    
}

data class  Leg(val nbleg: Int){

}

Une variable non nul déclarée avec le mot clé lateinit lors de sa déclaration peut est initialiser plus tard partout dans votre code.

Mais vous devez obligatoirement initialiser la variable avant de l’utiliser pour éviter de générer l’exception :  UninitializedPropertyAccessException: lateinit property has not been initialized .

Par exemple vous aller générer l’exception précédente si vous utilisez une variable sans l’initialiser comme suit.

data class Personn(val nom: String,val prenom: String){
  lateinit var leg: Leg
  init {
      print("Le nom de pieds de $nom $prenom est ${leg.nbleg}")//génrère l'exception
      leg=Leg(2)
  }

  fun affiche()="Le nom de pieds de $nom $prenom est ${leg.nbleg}"

}

data class  Leg(val nbleg: Int){

}

Notez que le mot clé lateinit peux être uniquement utilisé avec une variable var.Donc si vous déclarez une variable val avec lateinit comme suit, le compilateur vous signalera une erreur.

data class Personn(val nom: String,val prenom: String){
  lateinit val leg: Leg //Le compilateur signale une erreur
  init {
      leg=Leg(2)
  }

  fun affiche()="Le nom de pieds de $nom $prenom est ${leg.nbleg}"

}

De plus vous ne pouvez pas utiliser lateinit avec les types primitives tel que Long,Int ,Double etc. Voir l’exemple

 lateinit var n1: Int = 13  //Erreur
 lateinit var nom: String="" //Erreur

lateinit ne s’utilise pas dans un constructeur de classe. Si vous souhaitez utiliser lateinit dans la déclaration d’une variable dans une classe, vous devez déclarer la variable dans le corps de la classe comme suit.

data class Personn(lateinit var nom: String, lateinit var prenom: String){//Erreur
  
}

Pour tester si une variable lateinit est déjà initialiser vous pouvez utiliser la fonction isInitialized comme suit

data class Personn(val nom: String,val prenom: String){
  lateinit var leg: Leg
  init {
     if(::leg.isInitialized){
         print("Le nom de pieds de $nom $prenom est ${leg.nbleg}")
         //S'exécute uniquement si la variable leg est déja initialisée
     }
      leg=Leg(2)
  }

  fun affiche()="Le nom de pieds de $nom $prenom est ${leg.nbleg}"

}

data class  Leg(val nbleg: Int){

}

lazy

vous pouvez aussi utiliser le mot clé lazy pour retarder l’initialisation d’une variable. Contrairement à une variable déclarée avec le mot clé lateinit, une variable déclarée avec le mot clé lazy est initialiser lorsqu’elle veux être utilisée pour la première fois

Voir l’exemple suivant.

val nom :String by lazy {
     "VIGAN"
 }

Vous devez noter que lazy s’utilise avec une variable déclaré val.Puisque qu’une variable déclarée avec le mot val est immuable alors lorsque vous initialisez une variable déclarée

val avec le mot clé lazy et que vous l’initialisez avant sa première utilisation, sa valeur ne peut plus changer. Voir l’exemple

Si vous déclarez une variable var avec le mot clé lazy , le compilateur vous signalera qu’il ya une erreur comme dans l’exemple suivant.

 var nom :String by lazy {//le compilateur signale une erreur
     "VIGAN"
 }
 

Conclusion

Voila, nous sommes à la fin de ce tutoriel sur les mots clé lateinit et lazy. J’espère que ce tutoriel vous aidera.A bientôt pour un nouveau tutoriel.

Autres ressources

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


Partager

Laisser un commentaire

Résoudre : *
23 + 23 =


%d