Konstruktørkæde i Java

Hvad er Constructor Chaining?

En konstruktør i Java er en specifik metode, der bruges til objektoprettelse af en klasse. Konstruktøren påkaldes hver gang et objekt i klassen oprettes. Det kan bruges til at tildele værdier til objektets egenskaber på oprettelsestidspunktet. Der kan være flere konstruktører i en Java-klasse med forskellige parameterlister. Konstruktørkæder bruges til at påkalde forskellige implementeringer af konstruktører af samme klasse/overordnede klasse på tidspunktet for objektoprettelse.

Hvordan implementeres constructor chaining i Java?

Der er to måder at sammenkæde konstruktører baseret på, hvordan man kalder konstruktøren. De er som følger.

• ved at bruge dette() nøgleord – for at kalde konstruktører af samme klasse
• ved at bruge super() nøgleord – til at kalde konstruktører af den overordnede klasse

Dette er forklaret i de følgende eksempler.

Konstruktørkædeeksempel #1 – Konstruktører kædes sammen med dette() nøgleord

Vi har erklæret fire konstruktører til DerivedClass. En uden argumenter og de tre andre med forskellige argumenter. Inde i hver konstruktør bruges dette() nøgleord til at kalde den næste konstruktør af samme klasse.

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

Udførslen af ​​udførelsen

Konstruktørkædeeksempel #2 – Konstruktører kædes sammen med nøgleordet super().

Her kalder den underordnede klasse konstruktørerne af den overordnede klasse ved hjælp af nøgleordet super() . BaseClass har tre konstruktører. Konstruktøren uden argumenter kalder en af ​​de tre-argument-konstruktører i BaseClass ved hjælp af 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 har to konstruktører, der hver kalder de forskellige konstruktører af superklassen ved hjælp af 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();
    }
}

Udførslen af ​​udførelsen

Implicit vs. eksplicit konstruktørkald

Java har to forskellige måder at kalde konstruktører på: Implicit kald og eksplicit kald.

• Eksplicit kald refererer til at kalde konstruktører eksplicit i koden ved hjælp af this() eller super() .
• Implicit kald refererer til kald af superklassens no-argument constructor implicit ved fravær af et sådant eksplicit kald fra child class constructor. Med andre ord tilføjer compileren super()- kaldet som den første linje i en hvilken som helst af konstruktørerne af de underordnede klasser, hvis programmøren eksplicit ikke kalder super() i koden.

Hvorfor har vi brug for konstruktørkæder?

Der er flere forskellige formål med at have en konstruktørkæde i Java, som angivet nedenfor.

• Det er en måde at få adgang til egenskaberne for andre konstruktører eller egenskaber for overordnede klasser.
• Mens du kalder andre konstruktører, bliver der kun brugt ét objekt, som er den aktuelle forekomst af klassen. Initialiseringen sker ét sted, men vi har privilegiet at kalde forskellige konstruktørimplementeringer gennem en kæde. Dette hjælper meget med hukommelsesstyring og kodevedligeholdelse.

Konklusion

I denne tutorial diskuterede vi konstruktørkæde i Java. Konstruktører er metodelignende kodesegmenter, der påkaldes, mens der skabes objekter. En Java-klasse kan have et hvilket som helst antal konstruktører med forskellige parameterlister. Konstruktørkæde er en praktisk måde at håndtere forskellige initialiseringer med én forekomst af en klasse. Nogle vigtige punkter, der skal bemærkes fra denne tutorial, er anført nedenfor.

• Hvis programmøren ikke føjer det eksplicit til koden, tilføjer compileren en offentlig no-argument constructor til Java-klassen. Dette kaldes standardkonstruktøren.
• this() og super() skal skrives som den første linje i konstruktøren.
• this() bruges til at kalde konstruktører af samme klasse, mens super() bruges til at kalde konstruktører af den umiddelbare superklasse.
• Der skal være mindst én konstruktør i klassen, der ikke indeholder dette() nøgleord.
• Hvis det ikke tilføjes eksplicit, tilføjer compileren et no-argument super() -kald til hver underordnede klassekonstruktør. Dette vil hjælpe instansieringen af ​​klasser korrekt.