1. Syntax der Konstruktorüberladung
Im wirklichen Leben werden Objekte selten alle auf dieselbe Weise erzeugt. Stellen Sie sich die Klasse Person (Mensch) vor. Manchmal müssen wir eine Person nur mit ihrem Namen erstellen. Manchmal – mit Name und Alter. Und manchmal wissen wir gar nichts; dann sollen Standardwerte gelten. Es wäre seltsam, den Nutzer der Klasse zu zwingen, stets alle Parameter anzugeben, selbst wenn er sie nicht braucht.
Die Überladung von Konstruktoren ist eine Möglichkeit, dem Nutzer einer Klasse die Wahl zu lassen: welche Parameter er bei der Erstellung eines Objekts angeben möchte und welche auf Standardwerte gesetzt bleiben. Das macht die Klasse flexibel und bequem in der Verwendung.
Analogie:
In einem Konstruktionsbüro werden Autos gebaut. Manche bestellen die Basisausstattung (ohne Klimaanlage, nur Lenkrad und Räder), andere wollen „Luxus“ (mit Sitzheizung, Wi‑Fi und am liebsten, dass das Auto selbst fährt). Aber das Auto ist trotzdem dieselbe Klasse – nur unterschiedliche Arten, es zusammenzubauen!
Überladung bedeutet, dass in einer Klasse mehrere Konstruktoren deklariert sind, jedoch mit unterschiedlichen Parametern (unterschiedliche Anzahl, Typen oder Reihenfolge). Sie heißen alle genauso wie die Klasse und besitzen keinen Rückgabetyp.
Beispiel: Klasse mit überladenen Konstruktoren
public class Person {
String name;
int age;
// Konstruktor ohne Parameter (Standard)
public Person() {
this.name = "Unbekannt";
this.age = 0;
}
// Konstruktor mit einem Parameter
public Person(String name) {
this.name = name;
this.age = 0;
}
// Konstruktor mit zwei Parametern
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
Jetzt können wir Objekte auf unterschiedliche Weise erstellen:
Person p1 = new Person(); // name = "Unbekannt", alter = 0
Person p2 = new Person("Bob"); // name = "Bob", alter = 0
Person p3 = new Person("Alice", 25); // name = "Alice", alter = 25
Wie weiß Java, welchen Konstruktor es verwenden soll?
Java betrachtet Anzahl und Typen der Argumente, die Sie nach new übergeben. Wenn Sie new Person("Bob") schreiben, sucht der Compiler einen Konstruktor mit einem Parameter vom Typ String. Wenn Sie new Person("Alice", 25) schreiben, wird ein Konstruktor mit den Parametern String und int benötigt.
2. Aufruf eines Konstruktors aus einem anderen: this(...)
Bei der Überladung kommt es oft vor, dass sich ein Teil des Codes wiederholt. Beispielsweise sollen alle Konstruktoren den Namen setzen, während das Alter – falls nicht angegeben – null sein soll. Um dieselbe Logik nicht in jedem Konstruktor zu duplizieren, kann man mit dem Schlüsselwort this(...) einen Konstruktor aus einem anderen aufrufen.
Beispiel
public class Person {
String name;
int age;
// Konstruktor mit zwei Parametern
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// Der Konstruktor mit einem Parameter ruft den anderen Konstruktor auf
public Person(String name) {
this(name, 0); // ruft Person(String name, int age) auf
}
// Der parameterlose Konstruktor ruft den anderen Konstruktor auf
public Person() {
this("Unbekannt", 0);
}
}
public Person(String name) {
this(name, 0); // ruft Person(String, int) auf
}Wichtige Regel: Der Aufruf eines anderen Konstruktors mit this(...) muss die erste Zeile des Konstruktors sein!
Wozu ist das gut?
- Reduziert Code-Duplikation.
- Wenn Sie die Initialisierungslogik ändern (z. B. den Standardwert anpassen), müssen Sie es nur an einer Stelle tun.
- Der Code wird sauberer und leichter wartbar.
3. Praxisbeispiele: Überladung in einer realen Klasse
Nehmen wir die Klasse Account – ein Bankkonto. Manchmal kennen wir nur den Namen des Inhabers, manchmal wollen wir direkt den Anfangssaldo angeben, und mitunter auch die Währung.
Beispielklasse mit überladenen Konstruktoren
public class Account {
String owner;
double balance;
String currency;
// Konstruktor mit drei Parametern
public Account(String owner, double balance, String currency) {
this.owner = owner;
this.balance = balance;
this.currency = currency;
}
// Konstruktor mit zwei Parametern (Standardwährung – "EUR")
public Account(String owner, double balance) {
this(owner, balance, "EUR");
}
// Konstruktor mit einem Parameter (Kontostand = 0, Währung = "EUR")
public Account(String owner) {
this(owner, 0.0, "EUR");
}
// Parameterloser Konstruktor (Inhaber – "Unbekannt", Kontostand = 0, Währung = "EUR")
public Account() {
this("Unbekannt", 0.0, "EUR");
}
public void printInfo() {
System.out.println(owner + ": " + balance + " " + currency);
}
}
Verwendung
public class Main {
public static void main(String[] args) {
Account acc1 = new Account("John", 1000, "USD");
Account acc2 = new Account("Mary", 500);
Account acc3 = new Account("Peter");
Account acc4 = new Account();
acc1.printInfo(); // John: 1000.0 USD
acc2.printInfo(); // Mary: 500.0 EUR
acc3.printInfo(); // Peter: 0.0 EUR
acc4.printInfo(); // Unbekannt: 0.0 EUR
}
}
Warum ist das praktisch?
- Man kann Objekte mit unterschiedlichem Detaillierungsgrad erzeugen.
- Man muss nicht jedes Mal alle Parameter angeben (besonders, wenn sie oft gleich sind).
- Die Klasse lässt sich leicht erweitern: Kommt ein neuer Parameter hinzu, kann man einfach einen weiteren Konstruktor ergänzen.
4. Typische Fehler bei der Konstruktorüberladung
Fehler Nr. 1: Verwechslung von Typen und der Parameterreihenfolge.
Wenn es zwei Konstruktoren gibt — Person(String name, int age) und Person(int age, String name) —, kann der Compiler sie zwar unterscheiden, für die Nutzer der Klasse ist das jedoch sehr verwirrend. Solche Situationen sollte man vermeiden.
Fehler Nr. 2: Fehlender Standardkonstruktor.
Wenn Sie nur Konstruktoren mit Parametern deklariert haben und dann versuchen, ein Objekt ohne Parameter zu erstellen, erhalten Sie einen Kompilierfehler. Fügen Sie einen parameterlosen Konstruktor hinzu, falls er benötigt wird.
Fehler Nr. 3: Versuch, einen anderen Konstruktor nicht in der ersten Zeile aufzurufen.
Der Aufruf this(...) muss immer die erste Zeile des Konstruktors sein. Steht davor etwas anderes, führt das zu einem Kompilierfehler.
Fehler Nr. 4: Endlosschleifen bei Konstruktoraufrufen.
Wenn ein Konstruktor sich selbst aufruft (direkt oder über eine Kette), führt das wegen unendlicher Rekursion zu einem Kompilierfehler.
Fehler Nr. 5: Nicht initialisierte Felder.
Wenn ein Feld im Konstruktor (oder in der Aufrufkette) nicht initialisiert wird, kann das Objekt in einen inkorrekten Zustand geraten. Stellen Sie sicher, dass alle Felder nach der Erstellung des Objekts sinnvolle Werte haben.
GO TO FULL VERSION