Wie man einen Konstruktor von einem anderen Konstruktor in Java aufruft: Ein Blick unter die Haube

Wie man einen Konstruktor von einem anderen in Java aufruft: Nicht offensichtliche Details, die Ihren Code verändern werden

Haben Sie jemals eine Java-Klasse mit 5–6 Konstruktoren geschrieben und das Gefühl gehabt, in Code-Duplizierung zu ertrinken? Oder haben Sie im Gegenteil auf fremden Code geschaut, in dem ein mysteriöses this(name, 0, true) auftauchte und sich gefragt: „Was ist das für eine Magie?“.

Die Frage „How do I call one constructor from another in Java?“ ist eine der beliebtesten auf Stack Overflow (tausende Aufrufe und hunderte Antworten). Und das nicht ohne Grund. Was scheinbar eine einfache Operation ist – der Aufruf eines Konstruktors – birgt viele Nuancen, die die Leistung, Lesbarkeit und sogar die Korrektheit des Programms beeinflussen.

In diesem Artikel zeigen wir nicht nur die Syntax. Wir werfen einen Blick unter die Haube der JVM, analysieren, wie der Compiler solche Aufrufe verarbeitet, und geben praktische Tipps, die sowohl für Anfänger als auch für erfahrene Entwickler nützlich sind.

Warum überhaupt einen Konstruktor von einem anderen aufrufen? Das Problem der Duplizierung

Stellen Sie sich vor, Sie schreiben eine Klasse User mit Pflichtfeldern (Name, E-Mail) und optionalen Feldern (Alter, Telefon). Sie möchten den Benutzern Ihrer API Flexibilität bieten: ein Objekt mit einem minimalen Datensatz oder mit allen Details zu erstellen.

Schlechter Ansatz (ohne Konstruktoraufruf):

public class User {    private String name;    private String email;    private int age;    private String phone;

    public User(String name, String email) {        this.name = name;        this.email = email;        this.age = 0;        // Standardwert        this.phone = null;   // Standardwert    }

    public User(String name, String email, int age) {        this.name = name;        this.email = email;        this.age = age;        this.phone = null;   // schon wieder Duplizierung    }

    public User(String name, String email, int age, String phone) {        this.name = name;        this.email = email;        this.age = age;        this.phone = phone;    }}

Hier weisen wir name und email dreimal zu. Beim Hinzufügen eines neuen Feldes müssten alle Konstruktoren angepasst werden. Dies verletzt das DRY-Prinzip (Don't Repeat Yourself) und erhöht das Fehlerrisiko.

Guter Ansatz (mit Konstruktoraufruf über this()):

public class User {    private String name;    private String email;    private int age;    private String phone;

    public User(String name, String email) {        this(name, email, 0, null);  // Delegieren an den "vollständigsten" Konstruktor    }

    public User(String name, String email, int age) {        this(name, email, age, null); // erneute Delegierung    }

    public User(String name, String email, int age, String phone) {        this.name = name;        this.email = email;        this.age = age;        this.phone = phone;    }}

Jetzt befindet sich die gesamte Initialisierungslogik in einem Konstruktor. Die anderen delegieren die Arbeit einfach an ihn, indem sie Standardwerte übergeben. Das ist prägnant, leicht zu warten und verringert die Wahrscheinlichkeit, ein Feld zu vergessen.

Syntax des Konstruktoraufrufs: this() und super()

In Java gibt es zwei Schlüsselwörter zum Aufrufen von Konstruktoren:

• this(Parameter) – ruft einen anderen Konstruktor derselben Klasse auf.
• super(Parameter) – ruft einen Konstruktor der Elternklasse auf.

Wichtigste Regel: Der Aufruf von this() oder super() muss die erste Anweisung im Konstruktor sein. Warum? Dazu später mehr.

Beispiel mit Vererbung:

class Animal {    private String species;

    public Animal(String species) {        this.species = species;        System.out.println("Animal constructor: " + species);