Constructorketening in Java

Wat is Constructor Chaining?

Een constructor in Java is een specifieke methode die wordt gebruikt bij het maken van objecten van een klasse. De constructor wordt aangeroepen telkens wanneer een object van de klasse wordt gemaakt. Het kan worden gebruikt om waarden toe te wijzen aan de eigenschappen van het object tijdens het maken. Er kunnen meerdere constructors in een Java-klasse zijn met verschillende parameterlijsten. Constructorkoppeling wordt gebruikt om verschillende implementaties van constructors van dezelfde klasse/ouderklasse aan te roepen tijdens het maken van het object.

Hoe wordt constructor chaining geïmplementeerd in Java?

Er zijn twee manieren om constructors te koppelen op basis van hoe de constructor moet worden aangeroepen. Ze zijn als volgt.

• dit() trefwoord gebruiken – om constructors van dezelfde klasse aan te roepen
• met super() trefwoord - om constructors van de bovenliggende klasse aan te roepen

Dit wordt uitgelegd in de volgende voorbeelden.

Constructor chaining voorbeeld #1 – Constructors worden geketend met behulp van dit() trefwoord

We hebben vier constructors gedeclareerd voor de DerivedClass. Een zonder argumenten en de andere drie met verschillende argumenten. Binnen elke constructor wordt dit() sleutelwoord gebruikt om de volgende constructor van dezelfde klasse aan te roepen.

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

De uitvoer van de uitvoering

Constructor chaining voorbeeld #2 – Constructors worden geketend met behulp van het super() trefwoord

Hier roept de onderliggende klasse de constructors van de bovenliggende klasse aan met behulp van het sleutelwoord super() . De BaseClass heeft drie constructors. De constructor zonder argumenten roept een van de constructors met drie argumenten van de BaseClass aan met 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);
    }
 
}

De DerivedClass heeft twee constructors, die elk de verschillende constructors van de superklasse aanroepen met behulp van 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();
    }
}

De uitvoer van de uitvoering

Impliciete versus expliciete constructoraanroep

Java heeft twee verschillende manieren om constructors aan te roepen: impliciet aanroepen en expliciet aanroepen.

• Expliciet aanroepen verwijst naar het expliciet aanroepen van constructors in de code met behulp van this() of super() .
• Impliciete aanroep verwijst naar het impliciet aanroepen van de constructor zonder argumenten van de superklasse bij afwezigheid van een dergelijke expliciete aanroep van de constructor van de onderliggende klasse. Met andere woorden, de compiler voegt de aanroep super() toe als de eerste regel van een van de constructors van de onderliggende klassen als de programmeur expliciet niet super() aanroept in de code.

Waarom hebben we constructor chaining nodig?

Er zijn verschillende doelen voor het hebben van een constructorketen in Java, zoals hieronder vermeld.

• Het is een manier om toegang te krijgen tot de eigenschappen van andere constructors of eigenschappen van bovenliggende klassen.
• Bij het aanroepen van andere constructors wordt slechts één object gebruikt, namelijk de huidige instantie van de klasse. De initialisatie gebeurt op één plaats, maar we hebben het voorrecht om verschillende constructorimplementaties via een keten aan te roepen. Dit helpt enorm bij geheugenbeheer en codeonderhoud.

Conclusie

In deze zelfstudie hebben we het koppelen van constructors in Java besproken. Constructors zijn methode-achtige codesegmenten die worden aangeroepen tijdens het maken van objecten. Een Java-klasse kan een willekeurig aantal constructors hebben met verschillende parameterlijsten. Constructor chaining is een handige manier om verschillende initialisaties af te handelen met één instantie van een klasse. Enkele belangrijke punten die in deze zelfstudie moeten worden opgemerkt, worden hieronder vermeld.

• Als de programmeur het niet expliciet aan de code toevoegt, voegt de compiler een openbare constructor zonder argumenten toe aan de Java-klasse. Dit wordt de standaardconstructor genoemd.
• this() en super() moeten worden geschreven als de eerste regel van de constructor.
• this() wordt gebruikt om constructors van dezelfde klasse aan te roepen terwijl super() wordt gebruikt om constructors van de directe superklasse aan te roepen.
• Er moet ten minste één constructor in de klasse zijn die dit() -trefwoord niet bevat .
• Indien niet expliciet toegevoegd, voegt de compiler een super()- aanroep zonder argumenten toe aan elke constructor van een onderliggende klasse. Dit zal helpen bij het correct instantiëren van klassen.