Konstruktorverkettung in Java

Was ist Konstruktorverkettung?

Ein Konstruktor in Java ist eine bestimmte Methode, die bei der Objekterstellung einer Klasse verwendet wird. Der Konstruktor wird jedes Mal aufgerufen, wenn ein Objekt der Klasse erstellt wird. Es kann verwendet werden, um den Eigenschaften des Objekts zum Zeitpunkt der Erstellung Werte zuzuweisen. In einer Java-Klasse kann es mehrere Konstruktoren mit unterschiedlichen Parameterlisten geben. Die Konstruktorverkettung wird verwendet, um zum Zeitpunkt der Objekterstellung unterschiedliche Implementierungen von Konstruktoren derselben Klasse/übergeordneten Klasse aufzurufen.

Wie wird die Konstruktorverkettung in Java implementiert?

Es gibt zwei Möglichkeiten, Konstruktoren zu verketten, je nachdem, wie der Konstruktor aufgerufen wird. Sie sind wie folgt.

• Verwenden des Schlüsselworts this() – um Konstruktoren derselben Klasse aufzurufen
• Verwenden des Schlüsselworts super() – zum Aufrufen von Konstruktoren der übergeordneten Klasse

Dies wird in den folgenden Beispielen erläutert.

Beispiel Nr. 1 für die Konstruktorverkettung: Konstruktoren werden mit dem Schlüsselwort this() verkettet

Wir haben vier Konstruktoren für die DerivedClass deklariert. Einer ohne Argumente und die anderen drei mit unterschiedlichen Argumenten. In jedem Konstruktor wird das Schlüsselwort this() verwendet, um den nächsten Konstruktor derselben Klasse aufzurufen.

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

Die Ausgabe der Ausführung

Beispiel Nr. 2 für die Konstruktorverkettung: Konstruktoren werden mit dem Schlüsselwort super() verkettet

Hier ruft die untergeordnete Klasse die Konstruktoren der übergeordneten Klasse mit dem Schlüsselwort super() auf . Die BaseClass verfügt über drei Konstruktoren. Der Konstruktor ohne Argumente ruft mit this() einen der Drei-Argument-Konstruktoren der BaseClass auf .

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

}

Die DerivedClass verfügt über zwei Konstruktoren, die jeweils mit super() die unterschiedlichen Konstruktoren der Superklasse aufrufen .

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

Die Ausgabe der Ausführung

Impliziter vs. expliziter Konstruktoraufruf

Java bietet zwei verschiedene Möglichkeiten, Konstruktoren aufzurufen: Impliziter Aufruf und expliziter Aufruf.

• Explizite Aufrufe beziehen sich auf den expliziten Aufruf von Konstruktoren im Code mithilfe von this() oder super() .
• Impliziter Aufruf bezieht sich auf den impliziten Aufruf des Konstruktors ohne Argumente der Oberklasse, wenn ein solcher expliziter Aufruf vom Konstruktor der untergeordneten Klasse fehlt. Mit anderen Worten: Der Compiler fügt den super()- Aufruf als erste Zeile eines beliebigen Konstruktors der untergeordneten Klassen hinzu, wenn der Programmierer super() im Code explizit nicht aufruft.

Warum brauchen wir Konstruktorverkettung?

Es gibt verschiedene Zwecke für eine Konstruktorkette in Java, wie unten aufgeführt.

• Es ist eine Möglichkeit, auf die Eigenschaften anderer Konstruktoren oder Eigenschaften übergeordneter Klassen zuzugreifen.
• Beim Aufruf anderer Konstruktoren wird nur ein Objekt verwendet, nämlich die aktuelle Instanz der Klasse. Die Initialisierung erfolgt an einem Ort, aber wir haben das Privileg, verschiedene Konstruktorimplementierungen über eine Kette aufzurufen. Dies hilft erheblich bei der Speicherverwaltung und Codepflege.

Abschluss

In diesem Tutorial haben wir die Konstruktorverkettung in Java besprochen. Konstruktoren sind methodenähnliche Codesegmente, die beim Erstellen von Objekten aufgerufen werden. Eine Java-Klasse kann beliebig viele Konstruktoren mit unterschiedlichen Parameterlisten haben. Die Konstruktorverkettung ist eine praktische Möglichkeit, verschiedene Initialisierungen mit einer Instanz einer Klasse zu verarbeiten. Einige wichtige Punkte, die Sie in diesem Tutorial beachten sollten, sind unten aufgeführt.

• Wenn der Programmierer es nicht explizit zum Code hinzufügt, fügt der Compiler der Java-Klasse einen öffentlichen Konstruktor ohne Argumente hinzu. Dies wird als Standardkonstruktor bezeichnet.
• this() und super() sollten als erste Zeile des Konstruktors geschrieben werden.
• this() wird verwendet, um Konstruktoren derselben Klasse aufzurufen, während super() verwendet wird, um Konstruktoren der unmittelbaren Superklasse aufzurufen.
• Es sollte mindestens einen Konstruktor innerhalb der Klasse geben, der das Schlüsselwort this() nicht enthält .
• Wenn nicht explizit hinzugefügt, fügt der Compiler jedem untergeordneten Klassenkonstruktor einen super()- Aufruf ohne Argumente hinzu . Dies hilft bei der korrekten Instanziierung von Klassen.