Les classes et objet dans Kotlin

Kotlin est à la fois un langage de programmation orienté objet et fonctionnel.Donc Kotlin supporte les concepts de classe, objet qu’on peut retrouver dans un langages de programmation orienté tel que Java.

Dans ce tutoriel,vous allez apprendre à créer une classe, ajouter des constructeurs à vos classes, créer des objets de ces classes et enfin découvrir les concepts de constructeur primaire et secondaire dans kotlin.

Les classes

Une classe est un modèle de définition des objets ayant des caractéristiques identiques( même propriétés et opérations).A partir d’une classe vous pouvez créer plusieurs d’objets et chaque objet sera une instance de cette classe.

Dans Kotlin, vous pouvez déclarer une classe avec le mot clé class.

Voici une exemple qui illustre comment créer une classe dans kotlin.

class Personne {
    
}

Il s’agit d’une simple déclaration de classe sans constructeur ni propriété.

Si la classe ne possède pas de corps, les accolades peuvent être omit comme suit.

class Personne

Vous pouvez créer une instance de cette classe comme suit.

fun main(){
 val personne = Personne()
}

class Personne 

Vous devez noter que vous n’avez pas besoin d’utiliser le mot clé new comme en Java pour créer un objet.

Les propriétés

Vous pouvez déclarer des propriétés et les initialiser directement dans le corps de la classe comme suit.

class Personne {
  val nom: String = "VIGAN"
  val prenom: String = "Joel"   
}

Ces propriétés peuvent être déclarer comme propriétés immuables (marquée avec mot clé val) ou comme propriétés mutables (marquée avec le mot clé var).

La déclaration complète d’une classe dans kotlin contient trois parties

Partie 1:Le mot clé class suivi du nom de la classe

Partie 2: L’entête de la classe constituée d’un constructeur primaire, de la liste des super classes si la classe hérite d’autres classes etc.

Partie 3: Le corps de la classe constitué des propriétés de la classe, des méthodes membres de la classe, des constructeurs secondaires, du bloc d’initialisation etc.Le corps de la classe est encapsulé par des accolades.

L’entête et la corps de la classe sont optionnels.Donc si la classe ne possède pas de corps, les accolades peuvent être omit comme suit.

class Personne 

Les constructeurs

Le constructeur est une méthode spéciale de classe utilisé pour initialiser les propriétés d’un objet de la classe lors de la création de l’objet.

Le constructeur est appelé durant la création de la classe.Vous devez aussi savoir que si vous ne déclarez pas un constructeur,le compilateur crée un constructeur par défaut pour votre classe qui servira à instancier la classe.

Dans kotlin,il existe deux types de constructeur: le constructeur primaire et le constructeur secondaire.

Les constructeur Primaire.

Le constructeur primaire fait partie de l’entête de la classe et est déclaré après le nom de la classe comme suit.

class Personne constructor (val nom: String, val prenom: String ){
  
}

Vous pouvez créer une objet de cette classe de la manière suivante

fun main(){
 val personne = Personne("VIGAN","Joel")
}

class Personne constructor (val nom: String, val prenom: String ){

}

Si le constructeur primaire ne possède aucune annotation ou des modificateurs d’accès(public, private,protected etc), le mot clé constructor peut être omit comme suit.

class Personne (val nom: String, val prenom: String ){
  
}

Vous pouvez voir le constructeur primaire comme l’entête d’une fonction avec des paramètres qui peuvent être utilisés à l’intérieur de la fonction.De la même façon que les propriétés d’une fonction sont accessibles dans la fonction, les propriétés du constructeur primaire sont accessibles dans toute la classe

Le bloc d’initialisation

Le constructeur primaire ne doit contenir aucun code.Le code d’initialisation de la classe peut est défini dans le bloc d’initialisation qui est préfixé avec le mot clé init .

class Personne constructor (var nom: String, var prenom: String ){
 init {
     nom=nom.toUpperCase()
 }
}

Dans cette exemple le bloc d’initialisation est utilisé pour transformer le nom en majuscule

Vous pouvez déclarer plusieurs blocs d’initialisation dans une classe et ces blocs d’initialisation seront exécutés dans l’ordre dans lequel ils apparaissent.

class Personne (var nom: String, var prenom: String ){
 init {
     nom=nom.toUpperCase()
     println("Le nom de la personne est $nom")
 }
 init {
     prenom=prenom.toUpperCase()
     println("Le prenom de la personne est $prenom")
 }   
    
}

L’exemple suivant montre comment créer une instance de la classe personne.

fun main(){
 val personne = Personne("vigan","Joel")
}

class Personne (var nom: String, var prenom: String ){
 init {
     nom=nom.toUpperCase()
     println("Le nom de la personne est $nom")
 }
 init {
     prenom=prenom.toUpperCase()
     println("Le prenom de la personne est $prenom")
 }

}

Résultat:
Le nom de la personne est VIGAN
Le prenom de la personne est JOEL

Le bloc d’initialisation peut aussi être utilisé pour initialiser les propriétés membres de la classe comme suit.

fun main(){
 val personne = Personne("vigan","Joel")
}

class Personne (var nom: String, var prenom: String ){
 val dateNaissance: Int
 val email: String
 init {
  dateNaissance = 2019
  email="toto@gmail.com"
  println("La date de naissance est $dateNaissance")
  println("L'email est $email")
 }

}

Résultat:
La date de naissance est 2019
L’email est toto@gmail.com

ET enfin, vous pouvez aussi initialiser les propriétés de la classe directement dans le corps de la classe comme suit

fun main(){
 val personne = Personne("vigan","Joel",2019)
}

class Personne (var nom: String, var prenom: String,val dateNaissance: Int ){
 val mDateNaissance: Int= dateNaissance //Initialisation
  init {
      println("La date de naissance est $mDateNaissance")
  }

}

Résultat:La date de naissance est 2019

Syntaxe pour déclarer et initialiser les propriétés d’une classe

Précédemment nous avons vu que vous pouvez déclarer et initialiser les propriété directement dans le corps d’un classe.

Mais, kotlin fournit une syntaxe concise pour déclarer les propriétés et les initialiser dans le constructeur primaire

class Personne  (var nom: String, var prenom: String,val dateNaissance: Int,val email: String ){
 
}

Vous pouvez créer une instance de cette classe comme suit.

val personne = Personne("vigan","Joel",2019,"toto@gmail.com")

Comme des propriétés normal d’une classes, les propriété déclarer dans le constructeur primaire peut être déclaré immuable (marquée avec le mot clé val) et mutable (marquée avec le mot clé var) .

Les valeurs par défaut des propriétés du constructeur primaire

Vous pouvez aussi affecter des valeurs par défaut aux propriétés du constructeur primaire comme suit

class Personne  (var nom: String = "VIGAN", var prenom: String = "Noé",val email: String="toto@gmail.com" ){

}

Ainsi vous pourrez omettre lors de la création de l’objet certaines valeurs des propriétés du constructeur primaire comme suit

 val personne = Personne("vigan","Joel",,"toto@gmail.com")
 val personne2 = Personne("VIGAN","Joel")
 val personne3 = Personne("VIGAN") 
 val personne4 = Personne()  

Les constructeur secondaire

Une classe peut aussi déclarer un ou plusieurs constructeurs appelés constructeur secondaire et préfixé par le mot clé constructor . Ce constructeur secondaire est dans la troisième partie de la déclaration d’une classe.

Délégation au constructeur primaire.

Lors de la création d’une objet d’une classe, le constructeur primaire doit toujours être initialiser. Si dans la déclaration de la classe il existe un constructeur primaire et un ou plusieurs constructeurs secondaires et que vous créez l’objet à partir d’un constructeur secondaire de cette classe , alors le constructeur secondaire doit déléguer au constructeur primaire l’initialisation des propriétés aux quelles il est lié.

Ce qui permettra de correctement construire l’objet .Donc même quand l’objet est créé à partir du constructeur secondaire toutes les propriétés de la classe seront bien initialisé,même ceux présent dans le constructeur primaire grâce à la délégation au constructeur primaire.

Voici l’exemple d’une classe avec un constructeur secondaire.

class Personne  (var nom: String , var prenom: String){

    constructor( nom: String,  prenom: String, email:String):this(nom,prenom){

    }
}

Vous pouvez créer une instance de la classe Personne soit en utilisant le constructeur primaire ou en utilisant le constructeur secondaire comme suit

 val personne = Personne ("VIGAN","Joel")
 var personne2 = Personne("VIGAN","Joel","toto@gmail;com") 

Une classe peut aussi avoir plusieurs constructeurs secondaires comme dans l’exemple suivant

class Personne  (var nom: String , var prenom: String){

    constructor( nom: String,  prenom: String, email:String):this(nom,prenom){
    }
    constructor( nom: String,  prenom: String, email:String,age: Int):this(nom,prenom){
    }
}

Il faut aussi savoir que,chaque constructeur secondaire doit toujours définir dans la liste de ses propriétés toutes les propriétés du constructeur primaire en plus de ses propres propriétés.

Le constructeur secondaire doit toujours être différent du constructeur primaire par la déclaration de leurs propriétés.

Par exemple si vous déclarez une classe avec un constructeur primaire et secondaire comme comme dans le cas suivant, le compilateur vous signale une erreur

class Personne  (var nom: String , var prenom: String){

    constructor( nom: String,  prenom: String):this(nom,prenom){
    }
    
}

Conclusion

Voila,nous sommes à la fin de ce tutoriel dans lequel, vous avez appris comment déclarer une classe , créez un objet et enfin appris la notion de constructeur dans kotlin. J’espère que ce tutoriel vous aidera à démarrer avec les classes dans Kotlin. A bientôt pour un nouveau tutoriel.

Autres ressources

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