Alle Tabs der Lerneinheit (Erklärung · Interaktiv verstehen · Praxis-Übung · Klausur-Quiz) als durchgehender Text. Ideal zum Wiederholen vor der Klausur, und für Suchmaschinen wie Google, Bing und KI-Suche (ChatGPT, Perplexity).
Teil 1·Erklärung
Diese Lerneinheit wurde für typische Bachelor-Klausuren konzipiert. So prüfen wir · Fehler entdeckt? Melde ihn uns oder markiere die fragliche Stelle direkt im Text oben.
Alle Tabs der Lerneinheit (Erklärung · Interaktiv verstehen · Praxis-Übung · Klausur-Quiz) als durchgehender Text. Ideal zum Wiederholen vor der Klausur, und für Suchmaschinen wie Google, Bing und KI-Suche (ChatGPT, Perplexity).
Du schreibst new Student("Müller", 1001) — was passiert in dieser einen Zeile? Java reserviert Speicher im Heap, ruft den Konstruktor auf, und der setzt die Felder. Aber WIE? Was passiert wenn du keinen Konstruktor definierst? Wieso darf man manche Felder nur über Methoden setzen? Genau das beantwortet dieses Topic. Klausur-Pflicht in 13/17 WInf-Prog-1-Klausuren.
Klausur-Tipp: Bei Fehler "no suitable constructor found" — du hast einen Konstruktor mit Parametern definiert und versuchst, das Objekt parameterlos zu erzeugen. Lösung: parameterlosen Konstruktor zusätzlich anlegen oder beim Aufruf Argumente liefern.
Anmelden, um den Fortschritt zu speichern.
Nächster Schritt
Aktives Abrufen festigt Wissen schneller als nochmal lesen.
Du schreibst new Student("Müller", 1001) — was passiert in dieser einen Zeile? Java reserviert Speicher im Heap, ruft den Konstruktor auf, und der setzt die Felder. Aber WIE? Was passiert wenn du keinen Konstruktor definierst? Wieso darf man manche Felder nur über Methoden setzen? Genau das beantwortet dieses Topic. Klausur-Pflicht in 13/17 WInf-Prog-1-Klausuren.
Konstruktor: Spezielle Methode, die beim
newaufgerufen wird und das frisch erzeugte Objekt initialisiert. Sichtbarkeit regelt, wer von außen auf Felder/Methoden zugreifen darf.
Wenn du keinen Konstruktor definierst, gibt Java dir einen kostenlos: parameterlos, leer.
public class Student {
String name;
int matrnr;
}
// kompiliert, weil Java automatisch einen Konstruktor anlegt:
// public Student() {}
Student s = new Student(); // name = null, matrnr = 0
s.name = "Müller";
s.matrnr = 1001;
Aber: sobald du selbst einen Konstruktor schreibst, ist der Default-Konstruktor weg. Klausur-Klassiker:
public class Student {
String name;
int matrnr;
public Student(String name, int matrnr) { // eigener Konstruktor
this.name = name;
this.matrnr = matrnr;
}
}
Student s = new Student(); // FEHLER — kein parameterloser Konstruktor mehr!
Konstruktor heißt genauso wie die Klasse, hat keinen Rückgabetyp (nicht mal
void).
public class Student {
String name;
int matrnr;
int semester;
public Student(String name, int matrnr) {
this.name = name;
this.matrnr = matrnr;
this.semester = 1; // Default
}
}
Das this.name = name löst den klassischen Namens-Konflikt: Parameter heißt name, Feld heißt auch name. this.name ist das Feld, name allein der Parameter.
Mehrere Konstruktoren mit unterschiedlichen Parametern — Java wählt automatisch den passenden.
public class Student {
String name;
int matrnr;
int semester;
public Student(String name, int matrnr) {
this(name, matrnr, 1); // ruft anderen Konstruktor (Constructor Chaining)
}
public Student(String name, int matrnr, int semester) {
this.name = name;
this.matrnr = matrnr;
this.semester = semester;
}
}
Student s1 = new Student("Müller", 1001); // Semester wird 1
Student s2 = new Student("Schulz", 1002, 5); // Semester = 5
this(...) ruft einen anderen Konstruktor derselben Klasse auf. Muss die ERSTE Zeile im Konstruktor sein.
Java hat 4 Sichtbarkeitsstufen (Modifier), die regeln wer von außen drauf zugreifen darf.
| Modifier | Klasse | Paket | Unterklasse | Andere |
|---|---|---|---|---|
| public | ✓ | ✓ | ✓ | ✓ |
| protected | ✓ | ✓ | ✓ | – |
| package-private (kein Keyword) | ✓ | ✓ | – | – |
| private | ✓ | – | – | – |
Eselsbrücke "PpPP": Public (alle), protected (Paket + Kinder), package-private (nur Paket), private (nur eigene Klasse).
Felder private + Getter/Setter public ist die Standard-Konvention. So kontrollierst du den Zugriff.
public class Student {
private int matrnr; // privat — kein direkter Zugriff von außen
public int getMatrnr() {
return matrnr;
}
public void setMatrnr(int neueNr) {
if (neueNr <= 0) throw new IllegalArgumentException("MatrNr muss positiv sein");
this.matrnr = neueNr; // hier kannst du Validation einbauen
}
}
Student s = new Student(...);
// s.matrnr = -1; // FEHLER — privat
s.setMatrnr(-1); // FEHLER zur Laufzeit (Exception)
Vorteile:
Sieh, wie new Heap reserviert, Konstruktor füllt, Felder zugreifbar werden:
Interaktive Visualisierung
Interaktive Komponente: probiere sie im Topic-Player oben aus.
- Default-Konstruktor verschwindet, sobald du selbst einen schreibst. Wenn du parameterlos auch brauchst → selbst hinzufügen.
this(...)als erste Zeile für Konstruktor-Chaining.this.feld = feldlöst Parameter-Feld-Konflikt.- private + Getter/Setter für Encapsulation. Public Felder sind Klausur-Anti-Pattern.
- Sichtbarkeits-Reihenfolge: public > protected > package > private (von offen zu eng).
1. Konstruktor mit Return-Typ. Falsch: public void Student(...). Das ist eine normale Methode, kein Konstruktor (gleicher Name ist Zufall). Konstruktor: kein Rückgabetyp, nicht mal void.
2. Default-Konstruktor erwartet. Student s = new Student(); schlägt fehl, sobald du einen anderen Konstruktor definiert hast. Java erstellt ihn nicht mehr automatisch.
3. private Felder über Vererbung. Subklassen können private Felder der Oberklasse NICHT direkt zugreifen — nur über protected/public Getter. Häufiger Klausur-Fehler.
4. this(...) an falscher Stelle. Muss erste Zeile im Konstruktor sein. Wenn du erst this.x = 1; schreibst und dann this(...), gibt's Compile-Error.
5. Package-private vergessen. Wenn du keinen Modifier schreibst (int x;), ist es package-private, nicht private. Klausur-Frage.
Geh schrittweise durch was bei new Student("Müller", 1001) passiert: Heap-Reservierung, Konstruktor-Aufruf, Feld-Initialisierung, Zugriffsrechte.
Interaktive Visualisierung
Interaktive Komponente: probiere sie im Topic-Player oben aus.
Klausur-Tipp: Bei Fehler "no suitable constructor found" — du hast einen Konstruktor mit Parametern definiert und versuchst, das Objekt parameterlos zu erzeugen. Lösung: parameterlosen Konstruktor zusätzlich anlegen oder beim Aufruf Argumente liefern.
6 Aufgaben zu Default-Constructor, Overloading, Sichtbarkeitsmodifier.
Klausurfragen mit Lösungen (6)
Antwort: Konstruktoren haben keinen Rückgabetyp
Erklärung: Konstruktoren haben keinen Rückgabetyp (auch nicht void). Der Name ist identisch zur Klasse. "public void Student(...)" wäre eine normale Methode mit zufällig gleichem Namen, kein Konstruktor.
Antwort: Der Default-Konstruktor verschwindet, parameterloses 'new' geht nicht mehr
Erklärung: Sobald du EINEN eigenen Konstruktor definierst, gibt Java den automatischen Default-Konstruktor nicht mehr aus. Wenn du parameterlos UND mit Parametern brauchst, musst du beide selbst definieren.
Antwort: protected
Erklärung: protected: gleiche Klasse + gleiches Paket + Subklassen (auch in anderen Paketen). Public wäre überall, package-private nur im Paket (auch Subklassen in anderen Paketen nicht), private nur in der Klasse.
Antwort: Falsch
Erklärung: FALSCH. private bedeutet WIRKLICH nur innerhalb derselben Klasse. Subklassen müssen den Umweg über protected/public Getter/Setter nehmen. Häufiger Klausur-Stolperstein.
Typ: Wahr/Falsch
Richtige Antworten: Felder privat + Getter/Setter public ist Standard-Pattern; Encapsulation ermöglicht Validation beim Setzen; Encapsulation erlaubt Read-Only-Felder (nur Getter, kein Setter); Interne Implementierung kann ohne Bruch externen Codes geändert werden
Erklärung: Richtig: private+Getter/Setter Standard, Validation, Read-Only-Felder, interne Änderungen ohne externen Bruch. Falsch: Performance-Unterschied ist vernachlässigbar (JIT optimiert weg); technischer Vorteil ist real (Kontrolle).
Typ: Multi-Select
Zuordnungen:
Erklärung: Standard-Sichtbarkeits-Matrix. Auswendig lernen — Klausur-Klassiker.
Typ: Zuordnung
Klausurfragen mit Lösungen (6)
Antwort: this(...) muss erste Zeile sein
Erklärung: this(...) MUSS die erste ausführbare Zeile im Konstruktor sein. Genauso super(...) bei Subklassen. Wenn beides, dann super(...) zuerst, this(...) ist exklusiv (nur eine der beiden).
Antwort: Setzt das Feld auf den Parameter-Wert
Erklärung: this.name (Feld) = name (Parameter). Notwendig wenn Parameter und Feld gleichen Namen haben. Ohne this würde 'name = name' den Parameter auf sich selbst setzen — Feld bliebe unverändert.
Antwort: Falsch
Erklärung: FALSCH. Ohne Modifier ist es 'package-private' (auch 'default' genannt). Im selben Paket zugreifbar, in anderen Paketen NICHT (auch nicht von Subklassen).
Typ: Wahr/Falsch
Richtige Reihenfolge:
Erklärung: Standard-Lebenszyklus eines new-Aufrufs. Erst Speicher, dann Default-Werte, dann Konstruktor (mit super-Kette), dann Custom-Body, am Ende Referenz.
Typ: Reihenfolge
Antwort: Über einen protected oder public Getter in A
Erklärung: Standard-Weg: A definiert einen protected/public Getter (z.B. getX()), den B aufrufen kann. Reflection geht technisch (Field.setAccessible(true)), ist aber kein Pattern. Direkter Zugriff auf private von außen (inkl. Sub) ist verboten.
Lösungen pro Lücke:
Erklärung: Pflichtwissen Konstruktor + Sichtbarkeit. Diese 4 Lücken decken die häufigsten Klausur-Fragen ab.
Typ: Lückentext