Konstruktor-Überladung in Java – Erklärt mit praktischen Code-Beispielen

Was ist ein Konstruktor in Java?

Ein Konstruktor ist eine spezielle Methode, die ein neu erstelltes Objekt unmittelbar nach der Speicherallokation initialisiert. Er setzt die Felder des Objekts auf gewünschte Werte oder, falls weggelassen, auf ihre Standardwerte. Das Definieren eines Konstruktors ist optional; wird keiner bereitgestellt, liefert der Compiler einen Standardkonstruktor, der die üblichen Standardwerte zuweist:

• Numerische Primitivtypen (int, double usw.) → 0
• char → '\0'
• Objektreferenzen → null

Dieses Tutorial behandelt:

• Regeln für die Erstellung von Konstruktoren
• Konstruktor-Überladung
• Konstruktorverkettung

Regeln für die Erstellung eines Java-Konstruktors

1. Der Name des Konstruktors muss exakt dem Klassennamen entsprechen.
2. Er darf keinen Rückgabetyp haben, nicht einmal void.

Beispiel 1 – Erster Konstruktor

Schritt 1: Fügen Sie den folgenden Code in Ihren Java-Editor ein.

class Demo {
    int value1;
    int value2;
    Demo() {
        value1 = 10;
        value2 = 20;
        System.out.println("Inside Constructor");
    }
    public void display() {
        System.out.println("Value1 === " + value1);
        System.out.println("Value2 === " + value2);
    }
    public static void main(String[] args) {
        Demo d1 = new Demo();
        d1.display();
    }
}

Schritt 2: Kompilieren und ausführen. Ausgabe:

Inside Constructor
Value1 === 10
Value2 === 20

Konstruktor-Überladung in Java

Java erlaubt einer Klasse, mehrere Konstruktoren mit unterschiedlichen Parameterlisten zu definieren. Der Compiler unterscheidet sie anhand der Anzahl und Typen der Parameter.

Gültige Konstruktoren für eine Klasse namens Account könnten so aussehen:

Account(int a);
Account(int a, int b);
Account(String a, int b);

Beispiel 2 – Überladene Konstruktoren

Schritt 1: Fügen Sie den folgenden Code ein.

class Demo {
    int value1;
    int value2;
    /* Demo() {
        value1 = 10;
        value2 = 20;
        System.out.println("Inside 1st Constructor");
    } */
    Demo(int a) {
        value1 = a;
        System.out.println("Inside 2nd Constructor");
    }
    Demo(int a, int b) {
        value1 = a;
        value2 = b;
        System.out.println("Inside 3rd Constructor");
    }
    public void display() {
        System.out.println("Value1 === " + value1);
        System.out.println("Value2 === " + value2);
    }
    public static void main(String[] args) {
        Demo d1 = new Demo();
        Demo d2 = new Demo(30);
        Demo d3 = new Demo(30, 40);
        d1.display();
        d2.display();
        d3.display();
    }
}

Schritt 2: Kompilieren und ausführen. Sie erhalten einen Fehler, weil der Standardkonstruktor Demo() fehlt, nachdem Sie einen parameterisierten Konstruktor hinzugefügt haben. Um den Standardkonstruktor zu nutzen, deklarieren Sie ihn explizit:

Demo() {
    // Standardinitialisierung oder benutzerdefinierte Logik
}

Nach dem Einkommentieren des kommentierten Blocks und erneuten Kompilieren läuft das Programm korrekt.

Konstruktorverkettung

Wenn eine Unterklasse instanziiert wird, wird zuerst der Superklassenkonstruktor ausgeführt – dies wird als Konstruktorverkettung bezeichnet.

Beispiel 3 – Verkettung zwischen Eltern- und Kindklasse

Schritt 1: Kopieren Sie den folgenden Code.

class Demo {
    int value1;
    int value2;
    Demo() {
        value1 = 1;
        value2 = 2;
        System.out.println("Inside 1st Parent Constructor");
    }
    Demo(int a) {
        value1 = a;
        System.out.println("Inside 2nd Parent Constructor");
    }
    public void display() {
        System.out.println("Value1 === " + value1);
        System.out.println("Value2 === " + value2);
    }
    public static void main(String[] args) {
        DemoChild d1 = new DemoChild();
        d1.display();
    }
}
class DemoChild extends Demo {
    int value3;
    int value4;
    DemoChild() {
        // super(5); // Einkommentieren, um den überladenen Elternkonstruktor aufzurufen
        value3 = 3;
        value4 = 4;
        System.out.println("Inside the Constructor of Child");
    }
    public void display() {
        System.out.println("Value1 === " + value1);
        System.out.println("Value2 === " + value2);
        System.out.println("Value3 === " + value3);
        System.out.println("Value4 === " + value4);
    }
}

Schritt 2: Programm ausführen. Da der Kindkonstruktor nicht explizit super() aufruft, läuft zuerst der Standard-Demo()-Konstruktor. Erwartete Ausgabe:

Inside 1st Parent Constructor
Inside the Constructor of Child
Value1 === 1
Value2 === 2
Value3 === 3
Value4 === 4

Schritt 3: Um den überladenen Elternkonstruktor Demo(int a) aufzurufen, platzieren Sie super(5); als erste Zeile im Kindkonstruktor. Nach dem Einkommentieren und erneutem Ausführen:

Inside 2nd Parent Constructor
Inside the Constructor of Child
Value1 === 5
Value2 === 0
Value3 === 3
Value4 === 4

Die Verwendung von super(...) ist obligatorisch, wenn Sie einen bestimmten Superklassenkonstruktor benötigen, bevor die Unterklassenlogik ausgeführt wird.