Constructor Chaining în Java

Ce este Constructor Chaining?

Un constructor în Java este o metodă specifică utilizată în crearea de obiecte a unei clase. Constructorul este invocat de fiecare dată când este creat un obiect al clasei. Poate fi folosit pentru a atribui valori proprietăților obiectului în momentul creării. Pot exista mai mulți constructori într-o clasă Java cu liste de parametri diferite. Înlănțuirea constructorilor este folosită pentru a invoca diferite implementări ale constructorilor aceleiași clase/clase părinte la momentul creării obiectului.

Cum este implementată înlănțuirea constructorului în Java?

Există două moduri de înlănțuire a constructorilor bazate pe modul de apelare a constructorului. Ele sunt după cum urmează.

• folosind acest cuvânt cheie () – pentru a apela constructorii aceleiași clase
• folosind cuvântul cheie super() – pentru a apela constructorii clasei părinte

Acest lucru este explicat în exemplele următoare.

Exemplul #1 de înlănțuire a constructorilor – Constructorii sunt înlănțuiți folosind acest cuvânt cheie ().

Am declarat patru constructori pentru DerivedClass. Unul fără argumente și ceilalți trei cu argumente diferite. În interiorul fiecărui constructor, acest cuvânt cheie () este folosit pentru a apela următorul constructor al aceleiași clase.

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();
    }
}

Ieșirea execuției

Exemplul #2 de înlănțuire a constructorilor – Constructorii sunt înlănțuiți folosind cuvântul cheie super().

Aici, clasa copil apelează constructorii clasei părinte folosind cuvântul cheie super() . BaseClass are trei constructori. Constructorul fără argumente apelează unul dintre constructorii cu trei argumente ale clasei de bază folosind 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);
    }

}

DerivedClass are doi constructori, fiecare apelând diferiți constructori ai superclasei folosind super() .

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();
    }
}

Ieșirea execuției

Apelare implicită vs. explicită a constructorului

Java are două moduri diferite de a apela constructori: apelare implicită și apelare explicită.

• Apelarea explicită se referă la apelarea explicită a constructorilor în cod folosind this() sau super() .
• Apelarea implicită se referă la apelarea constructorului fără argument al superclasei implicit în absența unui astfel de apel explicit de la constructorul clasei copil. Cu alte cuvinte, compilatorul adaugă apelul super() ca prima linie a oricăruia dintre constructorii claselor copil dacă programatorul nu apelează în mod explicit super() în cod.

De ce avem nevoie de înlănțuirea constructorului?

Există mai multe scopuri diferite de a avea un lanț de constructori în Java, așa cum este enumerat mai jos.

• Este o modalitate de a accesa proprietățile altor constructori sau proprietățile claselor părinte.
• În timpul apelării altor constructori, este utilizat un singur obiect, care este instanța curentă a clasei. Inițializarea are loc într-un singur loc, dar avem privilegiul de a apela diferite implementări de constructor printr-un lanț. Acest lucru ajută foarte mult la gestionarea memoriei și la întreținerea codului.

Concluzie

În acest tutorial, am discutat despre înlănțuirea constructorului în Java. Constructorii sunt segmente de cod asemănătoare unei metode care sunt invocate în timpul creării obiectelor. O clasă Java poate avea orice număr de constructori cu liste de parametri diferite. Înlănțuirea constructorului este o modalitate utilă de a gestiona diferite inițializări cu o singură instanță a unei clase. Câteva puncte importante care trebuie remarcate din acest tutorial sunt enumerate mai jos.

• Dacă programatorul nu îl adaugă în mod explicit la cod, compilatorul adaugă un constructor public fără argument la clasa Java. Acesta se numește constructor implicit.
• this() și super() ar trebui să fie scrise ca prima linie a constructorului.
• this() este folosit pentru a apela constructorii aceleiași clase, în timp ce super() este folosit pentru a apela constructorii superclasei imediate.
• Ar trebui să existe cel puțin un constructor în cadrul clasei care nu conține acest cuvânt cheie ().
• Dacă nu este adăugat în mod explicit, compilatorul adaugă un apel super() fără argument la fiecare constructor de clasă copil. Acest lucru va ajuta la instanțierea corectă a claselor.