Chaînage de constructeurs en Java

Qu'est-ce que le chaînage de constructeur ?

Un constructeur en Java est une méthode spécifique utilisée dans la création d'objet d'une classe. Le constructeur est invoqué chaque fois qu'un objet de la classe est créé. Il peut être utilisé pour affecter des valeurs aux propriétés de l'objet au moment de la création. Il peut y avoir plusieurs constructeurs dans une classe Java avec différentes listes de paramètres. Le chaînage de constructeurs est utilisé pour invoquer différentes implémentations de constructeurs de la même classe/classe parent au moment de la création de l'objet.

Comment le chaînage des constructeurs est-il implémenté en Java?

Il existe deux façons de chaîner des constructeurs en fonction de la façon d'appeler le constructeur. Ils sont les suivants.

• en utilisant le mot-clé this() - pour appeler les constructeurs de la même classe
• en utilisant le mot-clé super() - pour appeler les constructeurs de la classe parent

Ceci est expliqué dans les exemples suivants.

Exemple de chaînage de constructeurs #1 – Les constructeurs sont chaînés à l'aide du mot-clé this()

Nous avons déclaré quatre constructeurs pour DerivedClass. Un sans arguments et les trois autres avec des arguments différents. A l'intérieur de chaque constructeur, le mot-clé this() est utilisé pour appeler le constructeur suivant de la même classe.

package com.tutorialwriting.constchaining;
 
public class DerivedClass{
 
    String firstName;
    String country;
    int age;
 
    public DerivedClass() {
        // calling one argument constructor
        this("Maggie");
    }
 
    public DerivedClass(String firstName) {
        // calling two argument constructor
        this(firstName, 15);
    }
 
    public DerivedClass(String firstName, int age) {
        // calling three argument constructor
        this(firstName, age, "Australia");
    }
 
    public DerivedClass(String firstName, int age, String country) {
        this.firstName = firstName;
        this.age = age;
        this.country = country;
    }
 
    void displayValues() {
        System.out.println("First Name : " + firstName);
        System.out.println("Country : " + country);
        System.out.println("Age : " + age);
    }
 
    public static void main(String args[]) {
        DerivedClass object = new DerivedClass();
        object.displayValues();
    }
}

Le résultat de l'exécution

Exemple de chaînage de constructeurs #2 – Les constructeurs sont chaînés à l'aide du mot-clé super()

Ici, la classe enfant appelle les constructeurs de la classe parent en utilisant le mot-clé super() . La BaseClass a trois constructeurs. Le constructeur sans arguments appelle l'un des constructeurs à trois arguments de BaseClass en utilisant this() .

package com.tutorialwriting.constchaining;
 
public class BaseClass {
 
    public BaseClass() {
        //calling a three argument constructor of the same class
        this("Male", "English", "1989/11/10");
        System.out.println("I'm executed third!!!");
    }
 
    public BaseClass(String firstName, String surname, int idNo) {
        System.out.println("I'm executed first!");
        System.out.println("First name : " + firstName);
        System.out.println("Surname : " + surname);
        System.out.println("ID Number : " + idNo);
    }
 
    public BaseClass(String gender, String nationality, String birthDate) {
        System.out.println("I'm executed second!!");
        System.out.println("Gender : " + gender);
        System.out.println("Nationality : " + nationality);
        System.out.println("Birth Date : " + birthDate);
    }
 
}

La DerivedClass a deux constructeurs, chacun appelant les différents constructeurs de la super classe en utilisant

package com.tutorialwriting.constchaining;
 
public class DerivedClass extends BaseClass {
 
    public DerivedClass() {
        //calling no argument constructor of the super class
        super();
    }
 
    public DerivedClass(String firstName, String surname, int idNo) {
        //calling three argument constructor of the super class
        super(firstName, surname, idNo);
    }
 
    public static void main(String args[]) {
        DerivedClass object2 = new DerivedClass("Paul", "Wilson", 123456);
        DerivedClass object1 = new DerivedClass();
    }
}

Le résultat de l'exécution

Appel de constructeur implicite ou explicite

Java a deux manières différentes d'appeler les constructeurs : l'appel implicite et l'appel explicite.

• L'appel explicite fait référence à l'appel explicite de constructeurs dans le code à l'aide de this() ou super() .
• L'appel implicite fait référence à l'appel implicite du constructeur sans argument de la super classe en l'absence d'un tel appel explicite du constructeur de la classe enfant. En d'autres termes, le compilateur ajoute l' appel super() comme première ligne de l'un des constructeurs des classes enfants si le programmeur n'appelle pas explicitement super() dans le code.

Pourquoi avons-nous besoin du chaînage des constructeurs ?

Il existe plusieurs objectifs différents d'avoir une chaîne de constructeurs en Java, comme indiqué ci-dessous.

• C'est un moyen d'accéder aux propriétés d'autres constructeurs ou aux propriétés des classes parentes.
• Lors de l'appel d'autres constructeurs, un seul objet est utilisé, qui est l'instance actuelle de la classe. L'initialisation se produit à un seul endroit, mais nous avons le privilège d'appeler différentes implémentations de constructeurs via une chaîne. Cela aide grandement à la gestion de la mémoire et à la maintenance du code.

Conclusion

Dans ce tutoriel, nous avons discuté du chaînage de constructeurs en Java. Les constructeurs sont des segments de code semblables à des méthodes qui sont invoqués lors de la création d'objets. Une classe Java peut avoir n'importe quel nombre de constructeurs avec différentes listes de paramètres. Le chaînage de constructeurs est un moyen pratique de gérer différentes initialisations avec une instance d'une classe. Certains points importants à noter dans ce didacticiel sont énumérés ci-dessous.

• Si le programmeur ne l'ajoute pas explicitement au code, le compilateur ajoute un constructeur public sans argument à la classe Java. C'est ce qu'on appelle le constructeur par défaut.
• this() et super() doivent être écrits sur la première ligne du constructeur.
• this() est utilisé pour appeler les constructeurs de la même classe tandis que super() est utilisé pour appeler les constructeurs de la super classe immédiate.
• Il doit y avoir au moins un constructeur dans la classe qui ne contient pas le mot-clé this() .
• S'il n'est pas ajouté explicitement, le compilateur ajoute un appel super() sans argument à chaque constructeur de classe enfant. Cela aidera l'instanciation des classes correctement.