Costruttore concatenamento in Java

Che cos'è il concatenamento del costruttore?

Un costruttore in Java è un metodo specifico utilizzato nella creazione di oggetti di una classe. Il costruttore viene richiamato ogni volta che viene creato un oggetto della classe. Può essere utilizzato per assegnare valori alle proprietà dell'oggetto al momento della creazione. Possono esserci più costruttori in una classe Java con diversi elenchi di parametri. Il concatenamento di costruttori viene utilizzato per richiamare diverse implementazioni di costruttori della stessa classe/classe genitore al momento della creazione dell'oggetto.

Come viene implementato il concatenamento del costruttore in Java?

Esistono due modi per concatenare i costruttori in base a come chiamare il costruttore. Sono i seguenti.

• usando la parola chiave this() – per chiamare i costruttori della stessa classe
• usando la parola chiave super() – per chiamare i costruttori della classe genitore

Questo è spiegato nei seguenti esempi.

Esempio di concatenamento del costruttore n. 1: i costruttori vengono concatenati utilizzando la parola chiave this()

Abbiamo dichiarato quattro costruttori per DerivedClass. Uno senza argomenti e gli altri tre con argomenti diversi. All'interno di ogni costruttore, la parola chiave this() viene utilizzata per chiamare il costruttore successivo della stessa 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();
    }
}

L'output dell'esecuzione

Esempio di concatenamento del costruttore n. 2: i costruttori vengono concatenati utilizzando la parola chiave super()

Qui, la classe figlia chiama i costruttori della classe genitore usando la parola chiave super() . BaseClass ha tre costruttori. Il costruttore senza argomenti chiama uno dei costruttori a tre argomenti della BaseClass usando 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 ha due costruttori, ognuno dei quali chiama i diversi costruttori della super classe usando 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();
    }
}

L'output dell'esecuzione

Chiamata implicita o esplicita del costruttore

Java ha due modi diversi di chiamare i costruttori: chiamata implicita e chiamata esplicita.

• La chiamata esplicita si riferisce alla chiamata esplicita dei costruttori nel codice utilizzando this() o super() .
• La chiamata implicita si riferisce alla chiamata implicita del costruttore senza argomenti della superclasse in assenza di tale chiamata esplicita dal costruttore della classe figlia. In altre parole, il compilatore aggiunge la chiamata super() come prima riga di uno qualsiasi dei costruttori delle classi figlie se il programmatore non chiama esplicitamente super() nel codice.

Perché abbiamo bisogno del concatenamento del costruttore?

Esistono diversi scopi per avere una catena di costruttori in Java, come elencato di seguito.

• È un modo per accedere alle proprietà di altri costruttori o alle proprietà delle classi padre.
• Durante la chiamata di altri costruttori, viene utilizzato un solo oggetto, che è l'istanza corrente della classe. L'inizializzazione avviene in un posto, ma abbiamo il privilegio di chiamare diverse implementazioni del costruttore attraverso una catena. Questo aiuta molto nella gestione della memoria e nella manutenzione del codice.

Conclusione

In questo tutorial, abbiamo discusso del concatenamento del costruttore in Java. I costruttori sono segmenti di codice simili a metodi che vengono richiamati durante la creazione di oggetti. Una classe Java può avere un numero qualsiasi di costruttori con diversi elenchi di parametri. Il concatenamento del costruttore è un modo pratico per gestire diverse inizializzazioni con un'istanza di una classe. Alcuni punti importanti da notare da questo tutorial sono elencati di seguito.

• Se il programmatore non lo aggiunge esplicitamente al codice, il compilatore aggiunge un costruttore pubblico senza argomenti alla classe Java. Questo è chiamato il costruttore predefinito.
• this() e super() dovrebbero essere scritti come prima riga del costruttore.
• this() viene utilizzato per chiamare i costruttori della stessa classe mentre super() viene utilizzato per chiamare i costruttori della superclasse immediata.
• Ci dovrebbe essere almeno un costruttore all'interno della classe che non contenga la parola chiave this() .
• Se non aggiunto in modo esplicito, il compilatore aggiunge una chiamata super() senza argomenti a ogni costruttore di classe figlio. Questo aiuterà l'istanziazione delle classi correttamente.