Konstruktörskedja i Java

Vad är Constructor Chaining?

En konstruktor i Java är en specifik metod som används vid objektskapande av en klass. Konstruktorn anropas varje gång ett objekt i klassen skapas. Den kan användas för att tilldela värden till objektets egenskaper vid skapandet. Det kan finnas flera konstruktorer i en Java-klass med olika parameterlistor. Konstruktörkedjning används för att anropa olika implementeringar av konstruktörer av samma klass/förälderklass vid tidpunkten för objektskapandet.

Hur implementeras constructor chaining i Java?

Det finns två sätt att kedja konstruktörer baserat på hur man anropar konstruktören. De är följande.

• använder this() nyckelord – för att anropa konstruktörer av samma klass
• med hjälp av nyckelordet super() – för att anropa konstruktörer av den överordnade klassen

Detta förklaras i följande exempel.

Konstruktörskedja exempel #1 – Konstruktörer är kedjade med hjälp av detta() nyckelord

Vi har deklarerat fyra konstruktörer för DerivedClass. En utan argument och de andra tre med olika argument. Inuti varje konstruktor används detta() nyckelord för att anropa nästa konstruktor i samma klass.

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

Utgången av utförandet

Konstruktörskedja exempel #2 – Konstruktörer är kedjade med hjälp av nyckelordet super().

Här anropar den underordnade klassen konstruktörerna för den överordnade klassen med hjälp av nyckelordet super() . BaseClass har tre konstruktörer. Konstruktören utan argument anropar en av tre-argument-konstruktörerna i BaseClass med hjälp av 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 två konstruktorer som var och en anropar de olika konstruktörerna i superklassen med hjälp av 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();
    }
}

Utgången av utförandet

Implicit kontra explicit konstruktoranrop

Java har två olika sätt att anropa konstruktörer: Implicit anrop och Explicit anrop.

• Explicit anrop hänvisar till att anropa konstruktörer uttryckligen i koden med hjälp av this() eller super() .
• Implicit anrop hänvisar till anropet av no-argument-konstruktören för superklassen implicit vid frånvaro av ett sådant explicit anrop från barnklasskonstruktorn. Med andra ord, kompilatorn lägger till super() -anropet som den första raden i någon av konstruktörerna för barnklasserna om programmeraren uttryckligen inte anropar super() i koden.

Varför behöver vi konstruktörskedja?

Det finns flera olika syften med att ha en konstruktörskedja i Java, som listas nedan.

• Det är ett sätt att komma åt egenskaperna för andra konstruktörer eller egenskaper för överordnade klasser.
• När andra konstruktörer anropas används endast ett objekt, vilket är den aktuella instansen av klassen. Initieringen sker på ett ställe, men vi har förmånen att anropa olika konstruktörsimplementeringar genom en kedja. Detta hjälper mycket i minneshantering och kodunderhåll.

Slutsats

I den här handledningen diskuterade vi konstruktorkedja i Java. Konstruktörer är metodliknande kodsegment som anropas när objekt skapas. En Java-klass kan ha valfritt antal konstruktorer med olika parameterlistor. Konstruktörskedja är ett praktiskt sätt att hantera olika initieringar med en instans av en klass. Några viktiga punkter att notera från denna handledning listas nedan.

• Om programmeraren inte lägger till det explicit i koden, lägger kompilatorn till en offentlig no-argument-konstruktor till Java-klassen. Detta kallas standardkonstruktorn.
• this() och super() ska skrivas som den första raden i konstruktorn.
• this() används för att anropa konstruktörer av samma klass medan super() används för att anropa konstruktörer av den omedelbara superklassen.
• Det bör finnas minst en konstruktor inom klassen som inte innehåller detta() nyckelord.
• Om det inte läggs till explicit, lägger kompilatorn till ett super()- anrop utan argument till varje underordnad klasskonstruktör. Detta kommer att hjälpa instansieringen av klasser korrekt.