Konstruktørkjeding i Java

Hva er Constructor Chaining?

En konstruktør i Java er en spesifikk metode som brukes i objektoppretting av en klasse. Konstruktøren påkalles hver gang et objekt i klassen opprettes. Den kan brukes til å tilordne verdier til egenskapene til objektet ved opprettelsestidspunktet. Det kan være flere konstruktører i en Java-klasse med forskjellige parameterlister. Konstruktørkjeding brukes til å påkalle forskjellige implementeringer av konstruktører av samme klasse/overordnede klasse på tidspunktet for objektoppretting.

Hvordan er konstruktørkjeding implementert i Java?

Det er to måter å kjede konstruktører basert på hvordan man kaller konstruktøren. De er som følger.

• ved å bruke dette() nøkkelordet – for å kalle konstruktører av samme klasse
• bruke super() nøkkelord – for å kalle konstruktører av overordnet klasse

Dette er forklart i de følgende eksemplene.

Konstruktørkjedeeksempel #1 – Konstruktører lenkes ved å bruke dette() nøkkelordet

Vi har erklært fire konstruktører for DerivedClass. En uten argumenter og de tre andre med forskjellige argumenter. Inne i hver konstruktør brukes dette() nøkkelordet til å kalle neste konstruktør av 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();
    }
}

Utgangen av utførelsen

Konstruktørkjedeeksempel #2 – Konstruktører lenkes ved hjelp av nøkkelordet super().

Her kaller barneklassen konstruktørene til den overordnede klassen ved å bruke nøkkelordet super() . BaseClass har tre konstruktører. Konstruktøren uten argumenter kaller en av de tre-argument-konstruktørene til BaseClass ved å bruke denne() .

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 som hver kaller de forskjellige konstruktørene i superklassen ved å bruke 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();
    }
}

Utgangen av utførelsen

Implisitt vs. eksplisitt konstruktørkall

Java har to forskjellige måter å kalle konstruktører: Implisitt kall og Eksplisitt kall.

• Eksplisitt kall refererer til å kalle konstruktører eksplisitt i koden ved å bruke this() eller super() .
• Implisitt kall refererer til kallet av no-argument-konstruktøren til superklassen implisitt ved fravær av et slikt eksplisitt kall fra barneklassekonstruktøren. Med andre ord, kompilatoren legger til super() -kallet som den første linjen i noen av konstruktørene til barneklassene hvis programmereren eksplisitt ikke kaller super() i koden.

Hvorfor trenger vi konstruktørkjeding?

Det er flere forskjellige formål med å ha en konstruktørkjede i Java, som listet nedenfor.

• Det er en måte å få tilgang til egenskapene til andre konstruktører eller egenskaper til overordnede klasser.
• Mens du kaller andre konstruktører, brukes bare ett objekt, som er den gjeldende forekomsten av klassen. Initialiseringen skjer på ett sted, men vi har privilegiet å kalle forskjellige konstruktørimplementeringer gjennom en kjede. Dette hjelper mye med minneadministrasjon og kodevedlikehold.

Konklusjon

I denne opplæringen diskuterte vi konstruktørkjeding i Java. Konstruktører er metodelignende kodesegmenter som påkalles mens de oppretter objekter. En Java-klasse kan ha et hvilket som helst antall konstruktører med forskjellige parameterlister. Konstruktørkjeding er en praktisk måte å håndtere forskjellige initialiseringer med én forekomst av en klasse. Noen viktige punkter å merke seg fra denne opplæringen er listet opp nedenfor.

• Hvis programmereren ikke legger det eksplisitt til koden, legger kompilatoren til en offentlig konstruktør uten argumenter til Java-klassen. Dette kalles standardkonstruktøren.
• this() og super() skal skrives som den første linjen i konstruktøren.
• this() brukes til å kalle konstruktører av samme klasse mens super() brukes til å kalle konstruktører av den umiddelbare superklassen.
• Det bør være minst én konstruktør i klassen som ikke inneholder dette() nøkkelordet.
• Hvis det ikke er lagt til eksplisitt, legger kompilatoren til et no-argument super() -kall til hver underordnede klassekonstruktør. Dette vil hjelpe instansieringen av klasser riktig.