Konstruktoren und das this-Schlüsselwort

Diese Lektion ist zentral:
Sie erklärt, wie Objekte beim Erzeugen automatisch initialisiert werden, warum man this braucht, wie mehrere Konstruktoren zusammenarbeiten, und welche typischen Stolperfallen es gibt.
Ich erkläre wieder alles Schritt für Schritt, mit ausführlichen Beispielen und Code, den du direkt für deine Seite verwenden kannst.

Was ist ein Konstruktor?

Ein Konstruktor ist eine spezielle Methode, die automatisch aufgerufen wird,
wenn du ein neues Objekt mit new erzeugst.

Er hat:

den gleichen Namen wie die Klasse,
keinen Rückgabetyp (nicht einmal void),
und dient dazu, Felder (Attribute) direkt zu initialisieren.

public class Hund {
    String name;
    int alter;

    // Konstruktor
    public Hund() {
        name = "Unbekannt";
        alter = 0;
    }
}

Ablauf:

Hund h1 = new Hund();

→ ruft automatisch public Hund() auf
→ setzt die Werte name = "Unbekannt" und alter = 0
→ das Objekt ist vollständig initialisiert

Wichtig

Wenn du keinen eigenen Konstruktor schreibst,
legt Java automatisch einen parameterlosen Standardkonstruktor an.

Sobald du einen eigenen Konstruktor mit Parametern hinzufügst,
verschwindet dieser Standardkonstruktor – du musst ihn dann selbst definieren, wenn du ihn weiter brauchst.

Konstruktoren mit Parametern

Ein parametrisierter Konstruktor erlaubt es,
Werte direkt beim Erzeugen eines Objekts zu übergeben.

public class Hund {
    String name;
    int alter;

    public Hund(String n, int a) {
        name = n;
        alter = a;
    }

    void info() {
        System.out.println(name + " ist " + alter + " Jahre alt.");
    }
}

public class Main {
    public static void main(String[] args) {
        Hund h1 = new Hund("Ava", 4);
        Hund h2 = new Hund("Balu", 2);

        h1.info();
        h2.info();
    }
}

Ausgabe:

Ava ist 4 Jahre alt.
Balu ist 2 Jahre alt.

Erklärung:

Die Übergabe der Werte („Ava“, 4) erfolgt direkt beim Erzeugen.
Das Objekt hat sofort die richtigen Startwerte.

Das Schlüsselwort `this`

this bedeutet „dieses Objekt hier“.

Man nutzt es, wenn Parameter und Felder denselben Namen haben
oder um auf Methoden desselben Objekts zuzugreifen.

Beispiel mit identischen Namen:

public class Hund {
    String name;
    int alter;

    public Hund(String name, int alter) {
        this.name = name;   // "this.name" → Attribut des Objekts
        this.alter = alter; // rechter Ausdruck → Parameter
    }
}

Ohne this wäre der Parameter name gemeint,
nicht das Feld name des Objekts.

Faustregel:
Wenn du im Konstruktor oder in einer Methode Felder initialisierst,
verwende immer this, wenn der Parameter denselben Namen trägt.

Mehrere Konstruktoren (Überladung)

Eine Klasse kann mehrere Konstruktoren haben –
solange sie sich in der Parameterliste unterscheiden.
Das nennt man Konstruktorüberladung.

public class Hund {
    String name;
    int alter;

    // Konstruktor 1
    public Hund() {
        name = "Unbekannt";
        alter = 0;
    }

    // Konstruktor 2
    public Hund(String name) {
        this.name = name;
        alter = 0;
    }

    // Konstruktor 3
    public Hund(String name, int alter) {
        this.name = name;
        this.alter = alter;
    }

    void info() {
        System.out.println(name + " (" + alter + " Jahre)");
    }
}

Verwendung:

Hund h1 = new Hund();
Hund h2 = new Hund("Ava");
Hund h3 = new Hund("Balu", 2);

h1.info();  // Unbekannt (0 Jahre)
h2.info();  // Ava (0 Jahre)
h3.info();  // Balu (2 Jahre)

Konstruktorverkettung (`this(...)`)

Statt denselben Code mehrfach zu schreiben,
kannst du Konstruktoren innerhalb der Klasse aufrufen – mit this(...).

Damit ruft ein Konstruktor einen anderen Konstruktor derselben Klasse auf.

public class Hund {
    String name;
    int alter;

    public Hund() {
        this("Unbekannt", 0);  // ruft den zweiten Konstruktor auf
    }

    public Hund(String name) {
        this(name, 0);         // ruft den dritten Konstruktor auf
    }

    public Hund(String name, int alter) {
        this.name = name;
        this.alter = alter;
    }
}

Regel:
this(...) muss immer die erste Anweisung im Konstruktor sein.

Vorteil: Kein doppelter Code, und alle Konstruktoren führen letztlich denselben Initialisierungspfad aus.

Beispiel: Mehrere Hunde mit unterschiedlichen Konstruktoren

public class Main {
    public static void main(String[] args) {
        Hund h1 = new Hund();
        Hund h2 = new Hund("Ava");
        Hund h3 = new Hund("Balu", 2);

        h1.info();
        h2.info();
        h3.info();
    }
}

Konsolenausgabe:

Unbekannt (0 Jahre)
Ava (0 Jahre)
Balu (2 Jahre)

Interaktive Visualisierung: Konstruktoren und `this`

Diese kleine Simulation zeigt,
wie verschiedene Konstruktoren aufgerufen werden
und wie sich die Werte im Objekt unterscheiden.

Interaktive Visualisierung: Konstruktoren und this

Konstruktor	Name	Alter

– Ausgabe der Java-Konsole –

Typische Fehlerquellen

Fehler	Ursache	Lösung
`constructor Hund() is undefined`	Nur Konstruktor mit Parametern vorhanden, aber `new Hund()` wird aufgerufen	Entweder passenden Konstruktor schreiben oder Werte übergeben
`this(...)` steht nicht an erster Stelle	`this(...)` darf nie hinter anderer Logik stehen	Immer die erste Zeile im Konstruktor
Parameter und Felder verwechselt	Gleichnamige Variablen ohne `this`	Immer `this.feldname = parameter`
Endlosschleife bei `this()`	Konstruktor ruft sich selbst auf	Nur Konstruktorverkettung in eine Richtung

Konstruktoren und das this-Schlüsselwort

Was ist ein Konstruktor?

Wichtig

Konstruktoren mit Parametern

Das Schlüsselwort this

Mehrere Konstruktoren (Überladung)

Konstruktorverkettung (this(...))

Beispiel: Mehrere Hunde mit unterschiedlichen Konstruktoren

Interaktive Visualisierung: Konstruktoren und this

Interaktive Visualisierung: Konstruktoren und this

Typische Fehlerquellen

Anmelden

Account Registrieren und Fortschritt Speichern!

Modal title

Das Schlüsselwort `this`

Konstruktorverkettung (`this(...)`)

Interaktive Visualisierung: Konstruktoren und `this`