Parlez-moi des initialisateurs dans les classes en Kotlin.

En Kotlin, les classes peuvent avoir un constructeur primaire et un ou plusieurs constructeurs secondaires. Les initialisateurs sont des blocs de code init qui s'exécutent dans l'ordre après leur déclaration, soit après le constructeur primaire (s'il existe), soit après le constructeur secondaire si aucun constructeur primaire n'est présent.

Constructeur primaire

Il est déclaré directement dans la déclaration de la classe. Il peut contenir des paramètres utilisés pour initialiser les propriétés.

class User(name: String, age: Int) {
    init {
        // Ce bloc s'exécute lors de la création d'une instance de la classe
        println("User créé : $name, $age")
    }
}

Constructeurs secondaires

Ils sont déclarés avec le mot-clé constructor et doivent toujours déléguer l'appel à un autre constructeur de la même classe, soit au primaire (via this), soit à un autre secondaire.

class User {
    init {
        // Ce bloc s'exécute en premier, s'il y a un constructeur primaire
    }

    constructor(name: String) : this() {
        // Constructeur secondaire 1
        println("User créé avec le nom : $name")
    }

    constructor(name: String, age: Int) : this(name) {
        // Constructeur secondaire 2, appelle le premier secondaire
        println("User créé avec le nom et l'âge : $name, $age")
    }
}

Ordre d'exécution

1. Le code dans le constructeur primaire (si des paramètres sont présents, ils sont utilisés).
2. Les blocs init dans l'ordre.
3. Le code dans le constructeur secondaire appelé (après délégation).

Exemple d'ordre d'exécution :

class Example {
    init {
        println("Bloc init 1")
    }

    constructor(i: Int) {
        println("Constructeur secondaire $i")
    }

    init {
        println("Bloc init 2")
    }
}

fun main() {
    Example(10)
}

Sortie :

Bloc init 1
Bloc init 2
Constructeur secondaire 10

Même si un constructeur secondaire est appelé, les blocs init s'exécutent toujours avant son corps. Cela garantit que l'initialisation principale de l'objet est terminée avant l'exécution du code spécifique du constructeur secondaire.

Les initialisateurs sont indispensables pour effectuer la logique qui doit être exécutée lors de la création de toute instance de la classe, indépendamment du constructeur utilisé. Par exemple, pour vérifier les données d'entrée ou configurer l'état de l'objet.