Java-Konstruktoren: Objekte mit new initialisieren

Warum es Konstruktoren gibt

Auf der vorherigen Seite hast du Klassen erstellt und Objekte mit new erzeugt. Ein Konstruktor ist der Code, der während dieses new-Aufrufs tatsächlich ausgeführt wird. Sein einziger Zweck ist es, dir ein einsatzbereites Objekt zurückzugeben – alle erforderlichen Felder gesetzt, kein halb initialisierter Zustand.

Ein Konstruktor sieht aus wie eine Methode, mit zwei Unterschieden: Er trägt den gleichen Namen wie die Klasse und hat keinen Rückgabetyp – nicht einmal void.

class Point {
    int x;
    int y;

    Point(int x, int y) {     // Konstruktor: gleicher Name wie die Klasse, kein Rückgabetyp
        this.x = x;
        this.y = y;
    }
}

public class Main {
    public static void main(String[] args) {
        Point p = new Point(3, 4);   // der Konstruktor läuft hier
        System.out.println(p.x + ", " + p.y);
    }
}

new Point(3, 4) reserviert das Objekt und führt dann den Konstruktorrumpf mit x = 3 und y = 4 aus. Wenn new zurückkehrt, ist p vollständig initialisiert.

Das Schlüsselwort this

Im Konstruktor oben heißen die Parameter x und y – genauso wie die Felder. this.x bedeutet „das Feld x, das zu diesem Objekt gehört", während ein einfaches x den Parameter meint. Ohne this würde x = x lediglich den Parameter sich selbst zuweisen und das Feld unberührt lassen.

class Account {
    String owner;
    double balance;

    Account(String owner, double balance) {
        this.owner = owner;       // Feld = Parameter
        this.balance = balance;
    }
}

public class Main {
    public static void main(String[] args) {
        Account a = new Account("Sam", 100.0);
        System.out.println(a.owner + " has " + a.balance);
    }
}

Du brauchst this nur, wenn ein Parameter ein Feld verdeckt, doch viele verwenden es der Klarheit halber überall. Der häufige Fehler besteht darin, es bei gleichen Namen zu vergessen: Der Code kompiliert, läuft und lässt deine Felder stillschweigend auf ihren Standardwerten (null, 0, false).

Der Standardkonstruktor

Wenn du nie einen Konstruktor schreibst, stellt Java unauffällig einen Standardkonstruktor bereit: einen öffentlichen, argumentlosen Konstruktor, der nichts Zusätzliches tut. Deshalb funktionierte new bei Klassen, die gar keinen Konstruktor hatten.

Der Haken: Sobald du irgendeinen Konstruktor schreibst, ist der geschenkte weg.

class Box {
    int size;

    Box(int size) {       // jetzt gibt es KEINEN argumentlosen Konstruktor
        this.size = size;
    }
}

new Box();   // Kompilierfehler: es existiert kein Konstruktor Box()

Wenn new Box() trotzdem funktionieren soll, deklariere den argumentlosen Konstruktor selbst:

class Box {
    int size;

    Box() {               // expliziter argumentloser Konstruktor
        this.size = 1;
    }

    Box(int size) {
        this.size = size;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(new Box().size);     // 1
        System.out.println(new Box(10).size);   // 10
    }
}

Konstruktor-Überladung

Eine Klasse kann mehrere Konstruktoren haben, solange sich ihre Parameterlisten unterscheiden – das ist einfach Methodenüberladung, angewendet auf Konstruktoren. Jeder bietet eine andere Möglichkeit, das Objekt zu erstellen.

class Rectangle {
    int width;
    int height;

    Rectangle() {                 // ein standardmäßiges 1x1-Quadrat
        this.width = 1;
        this.height = 1;
    }

    Rectangle(int side) {         // ein Quadrat
        this.width = side;
        this.height = side;
    }

    Rectangle(int width, int height) {   // ein vollständiges Rechteck
        this.width = width;
        this.height = height;
    }

    int area() { return width * height; }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(new Rectangle().area());        // 1
        System.out.println(new Rectangle(5).area());       // 25
        System.out.println(new Rectangle(2, 3).area());    // 6
    }
}

Java wählt anhand der Anzahl und der Typen der Argumente, die du an new übergibst, den passenden Konstruktor aus.

Verkettung mit this()

Beachte die Duplizierung oben: Jeder Konstruktor weist die Felder selbst zu. Das kannst du vermeiden, indem ein Konstruktor mit this(...) einen anderen aufruft. Der Aufruf muss die erste Anweisung im Konstruktor sein.

class Rectangle {
    int width;
    int height;

    Rectangle() {
        this(1, 1);          // delegiert an den Konstruktor mit zwei Argumenten
    }

    Rectangle(int side) {
        this(side, side);    // delegiert ebenfalls
    }

    Rectangle(int width, int height) {   // der einzige „echte" Konstruktor
        this.width = width;
        this.height = height;
    }
}

public class Main {
    public static void main(String[] args) {
        Rectangle r = new Rectangle(4);
        System.out.println(r.width + "x" + r.height);   // 4x4
    }
}

Nun liegt die eigentliche Initialisierung an einer einzigen Stelle. Die kleineren Konstruktoren füllen nur die Standardwerte ein und reichen die Arbeit weiter. Wenn du jemals versuchst, eine Anweisung vor this(...) zu setzen, weist der Compiler sie zurück.

Konstruktoren und super()

Jeder Konstruktor ruft implizit zuerst den Konstruktor seiner Oberklasse auf. Wenn du nichts schreibst, fügt Java ein verstecktes super() (den argumentlosen Konstruktor der Oberklasse) am Anfang des Rumpfs ein. Damit wirst du direkt arbeiten, sobald du beginnst, Unterklassen zu bilden – das ist das nächste Thema.

class Animal {
    String name;
    Animal(String name) { this.name = name; }
}

class Dog extends Animal {
    Dog(String name) {
        super(name);   // hier muss der Konstruktor der Elternklasse explizit aufgerufen werden
    }
}

Da Animal keinen argumentlosen Konstruktor hat, muss Dog super(name) ausdrücklich aufrufen – es gibt kein geschenktes super(), auf das man zurückgreifen könnte. Wie this() muss auch ein super(...)-Aufruf die erste Anweisung im Konstruktor sein.

Weiter: Vererbung

Konstruktoren initialisieren ein einzelnes Objekt, doch super() hat bereits etwas Größeres angedeutet: Klassen können auf anderen Klassen aufbauen und deren Felder, Methoden und Konstruktoren wiederverwenden. Diese Beziehung – eine Klasse, die eine andere erweitert – ist die Vererbung, und sie ist die nächste Seite.