Utilisation des constructeurs secondaires dans Kotlin

1. L’histoire des constructeurs secondaires dans Kotlin
2. Constructeurs secondaires Kotlin
3. Créer plusieurs constructeurs secondaires dans Kotlin
4. Appeler un constructeur secondaire à partir d’un autre constructeur secondaire existant
5. Appeler un constructeur secondaire à partir de la classe parent à partir d’un constructeur secondaire dans la classe enfant

Les constructeurs sont des fonctions membres appelées automatiquement lorsqu’un objet est créé dans un langage de programmation orienté objet.

Puisque Kotlin est un langage OOPS, il utilise également des constructeurs pour l’initialisation d’objet. Dans Kotlin, il existe deux constructeurs : les constructeurs primaires et les constructeurs secondaires.

Cet article présente le concept de constructeurs secondaires dans Kotlin et comment les utiliser.

L’histoire des constructeurs secondaires dans Kotlin

Les constructeurs secondaires n’étaient pas pris en charge dans Kotlin avant 2015. Jusque-là, les développeurs utilisaient l’une des techniques de soufflage pour résoudre la plupart des cas d’utilisation des constructeurs secondaires.

1. Définir une méthode de fabrique à côté de la classe.
2. Définition des valeurs par défaut des paramètres.
3. Utilisation d’une méthode de fabrique définie dans un autre objet.

Alors que ces techniques étaient assez bonnes, il y avait un besoin de constructeurs secondaires. Kotlin a commencé à soutenir les constructeurs secondaires avec le lancement de M11 en 2015.

Constructeurs secondaires Kotlin

Alors que les constructeurs primaires fournissent un moyen concis d’initialiser une classe, les constructeurs secondaires deviennent nécessaires lors de leur extension. De plus, le constructeur secondaire permet également d’ajouter une logique d’initialisation.

Alors que nous ne pouvons avoir qu’un seul constructeur principal dans un programme, Kotlin permet la création de plusieurs constructeurs secondaires.

Nous pouvons créer et utiliser des constructeurs secondaires dans Kotlin avec le mot-clé constructor. Un programme Kotlin peut avoir un ou plusieurs constructeurs secondaires.

Les constructeurs secondaires sont généralement évités, mais ils sont utilisés pour étendre une classe. La raison en est qu’ils aident à initialiser une seule classe de plusieurs manières via plusieurs constructeurs.

Syntaxe:

class ABC {
    constructor(data: String) {
        // code
}

Pour mieux comprendre les constructeurs secondaires, regardons l’exemple suivant. Nous allons créer un constructeur secondaire pour la classe Product qui affichera le produit de deux entiers.

Exemple de code :

fun main(args: Array<String>) {
    Product(3, 7)
}

class Product {
    //Creating a secondary constructor
    constructor(x: Int, y:Int){
        var i = x * y
            println("The product of integers 3 and 7 is: ${i}")
    }
}

Production:

Créer plusieurs constructeurs secondaires dans Kotlin

Nous pouvons également avoir plusieurs constructeurs dans Kotlin. Lequel des nombreux constructeurs appelés par le compilateur est décidé en fonction des arguments passés.

Exemple de code :

fun main(args: Array<String>) {
    Student(11035, "David")
    Student(11047,"Steve","New York")
}

class Student {

    constructor (std_id : Int, std_name: String ) {
        var id: Int = std_id
        var name: String = std_name
        print("Student's ID is: $id, ")
        println("Student's Name is: $name")
        println()
    }

    constructor (std_id : Int, std_name: String, std_city: String) {
        var id: Int = std_id
        var name: String = std_name
        var city: String = std_city
        print("Student's ID is: $id, ")
        print("Student's Name is: $name, ")
        println("Student's City is: $city")
    }
}

Production:

Appeler un constructeur secondaire à partir d’un autre constructeur secondaire existant

Nous pouvons appeler un constructeur secondaire dans Kotlin en utilisant un constructeur secondaire existant. Nous devons utiliser la fonction this().

Exemple de code :

fun main(args: Array<String>){
    Product(3,7)
}

class Product {
    // using this to call another secondary constructor
    constructor(x: Int,y:Int) : this(x,y,5) {
        var ProductOfTwo = x * y
        println("The product of the two integers is: $ProductOfTwo")
    }

    constructor(x: Int, y: Int,z: Int) {
        var ProductOfThree = x * y * z
        println("The product of the three integers is is: $ProductOfThree")
    }
}

Production:

Appeler un constructeur secondaire à partir de la classe parent à partir d’un constructeur secondaire dans la classe enfant

En plus d’appeler un constructeur secondaire à partir d’un autre, nous pouvons également appeler le constructeur secondaire d’une classe parent à partir du constructeur de la classe enfant. C’est semblable à l’héritage.

Nous devons utiliser le mot-clé super pour hériter du constructeur.

Exemple de code :

fun main(args: Array<String>) {
    childClass(11035, "David")
}

open class parentClass {

    constructor (std_id : Int, std_name: String, std_city: String) {
        var id: Int = std_id
        var name: String = std_name
        var city: String = std_city
        print("Student's ID is: $id, ")
        print("Student's Name is: $name, ")
        println("Student's City is: $city")
        println()
    }
}

class childClass : parentClass {

    constructor (std_id : Int, std_name: String):super(std_id,std_name,"New York"){
        var id: Int = std_id
        var name: String = std_name
        print("Student's ID is: $id, ")
        println("Student's Name is: $name")
    }
}

Production: