Überschreiben in Java
Schreibe eine Elternmethode auf dem Kind neu, damit der Aufruf den Kindkoerper nutzt. Behalte Truck extends Car. Auf Car behalte horn so, dass es beep druckt. Auf Truck schreibe horn erneut, sodass es honk druckt. In Yard.java baust du einen Truck und rufst t.horn() auf. Kompiliere mit javac Yard.java und starte java Yard. Der Bildschirm soll honk zeigen. Eine zweite Demo baut auch ein schlichtes Car, damit du beep vom Elternteil und honk vom Kind hoerst. Lass Interfaces fuer die naechste Seite — diese Lektion ist ein Methodenname mit zwei Koerpern.
Schreibe horn auf dem Kind neu
Die Vererbungsseite liess Truck leer, sodass t.horn() das Eltern-beep behielt. Die Super-Seite lief Konstruktoren mit super. Diese Seite aendert den Methodenkoerper auf dem Kind. Oeffne Yard.java. Halte den oeffentlichen Klassennamen Yard. Loesche uebrige nur-Konstruktor-Drucke von car und truck, wenn sie die Methodengeschichte begraben, uebrige Pfaddemos, Store-Schreiber und Tastatur-Scanner. Das Programm darf nicht auf Tippen warten. Du brauchst keine Importzeile.
Deklariere das Elternteil mit einer Instanzmethode, die beep druckt:
class Car {
void horn() {
System.out.println("beep");
}
}
Deklariere das Kind mit extends Car. In Truck schreibst du denselben Methodennamen erneut, aber du druckst honk:
void horn() {
System.out.println("honk");
}
Gleicher Name und gleiche leere Parameterliste bedeuten: die Kindversion ersetzt die Elternversion fuer Truck-Objekte. Du fuegst keine zweite, unverbundene Methode hinzu. Du ueberschreibst horn.
In Yard.main baust du einen Truck und rufst die Methode auf:
Truck t = new Truck();
t.horn();
Der Aufruf laeuft den Koerper, der auf Truck steht, also druckt der Bildschirm honk.
class Car {
void horn() {
System.out.println("beep");
}
}
class Truck extends Car {
void horn() {
System.out.println("honk");
}
}
public class Yard {
public static void main(String[] args) {
Truck t = new Truck();
t.horn();
}
}
Aus dem Ordner mit Yard.java startest du javac Yard.java. Wenn Klammern, geschweifte Klammern und Semikolons passen, schreibt javac keine eigene Zeile. Dann startest du java Yard — nicht java Yard.java. Lass die Endung .java beim Startbefehl weg. Halte eine oeffentliche Klasse in der Datei, damit der Name Yard passt. Die Hilfstypen Car und Truck bleiben in dieser Anfaengerform ohne public.
Der Bildschirm zeigt honk. Geh den Lauf einmal durch. Java startet bei Yard.main. new Truck() baut einen Truck. t.horn() schaut auf den echten Typ von t. Weil Truck sein eigenes horn schrieb, laeuft dieser Kindkoerper und druckt honk. Der Eltern-beep-Koerper bleibt auf Car und wird fuer diesen Truck-Aufruf nicht genutzt.
Siehst du noch beep, pruefe, ob Truck wirklich eine horn-Methode enthaelt. Ein leerer Truck von der Vererbungsseite erbt weiterhin beep. Ueberschreiben verlangt, dass die Kindmethode mit demselben Namen vorhanden ist. Siehst du noch car dann truck aus einer Konstruktor-Demo, wechsle zur Ueberschreiben-Lehrdatei und starte java Yard erneut.
Sag die Regel laut, waehrend du den Bildschirm siehst: gleicher Methodenname auf dem Kind, Kindkoerper gewinnt fuer dieses Objekt. Behalte extends Car, damit Truck eine Art Car bleibt. Ohne extends waere ein horn auf Truck eine eigene Typgeschichte, kein Ueberschreiben der Elternmethode.
Erfinde auf dieser Seite keine interface-Datei. Interfaces warten auf die naechste Lektion. Heute traegt eine Klassenhierarchie zwei horn-Koerper, und der Kindkoerper antwortet auf den Aufruf an einem Truck.
Eltern-beep und Kind-honk nebeneinander
Ein zweites Programm behält das Ueberschreiben. main baut ein Car und einen Truck, dann ruft es horn auf beiden auf. Das Elternteil druckt weiter beep. Das Kind druckt weiter honk.
class Car {
void horn() {
System.out.println("beep");
}
}
class Truck extends Car {
void horn() {
System.out.println("honk");
}
}
public class Yard {
public static void main(String[] args) {
Car c = new Car();
Truck t = new Truck();
c.horn();
t.horn();
}
}
Kompiliere mit javac Yard.java, dann starte java Yard. Der Bildschirm zeigt beep, dann honk. Die erste Zeile kommt vom Car-Objekt. Die zweite Zeile kommt vom Truck-Objekt. Ueberschreiben auf dem Kind loescht die Elternmethode nicht fuer Elternobjekte. Jedes Objekt nutzt den Koerper, der zu seinem eigenen Typ gehoert.
Lies die beiden horn-Methoden noch einmal. Gleicher Name. Gleiche leere Parameterliste. Anderer Drucktext. Diese Signatur-Gleichheit macht die Kindversion zum Ueberschreiben statt zu einer neuen, unverbundenen Methode. Benennst du die Kindmethode um, wuerde Vererbung wieder beep auf Trucks behalten, und du wuerdest kein Ueberschreiben mehr lehren.
Wenn uebrige Konstruktor-super()-Demos noch im Ordner liegen, behalte sie als Geschichte. Fuer diese Lektion starte die Ueberschreiben-Lehrdatei, damit der Bildschirm Methodendrucke zeigt, nicht Konstruktorreihenfolge-Woerter. Wenn javac ueber doppelte oeffentliche Klassen klagt, hast du noch mehr als eine oeffentliche Klasse in der Datei — halte nur Yard oeffentlich.
Elternkoerper versus Kindkoerper
📊 Who prints what for horn
| Role | horn body |
|---|---|
Parent Car |
prints beep |
Child Truck |
prints honk (overrides) |
Die Tabelle ist die kurze Karte dieser Seite. Vererbung allein wuerde beep auf beide Rollen legen, wenn das Kind leer bleibt. Nach dem Ueberschreiben wechselt die Kindzeile zu honk, waehrend die Elternzeile beep bleibt. Behalte diese Karte im Kopf, wenn die zweite Demo beide Zeilen druckt. |
Vergleich mit leerem extends und mit super
Auf der Vererbungsseite behielt leerer Truck Eltern-horn und druckte beep. Auf der Super-Seite liefen Konstruktoren durch super und druckten car dann truck. Auf dieser Seite aendert sich die Methode selbst auf dem Kind. Du brauchst weiterhin extends. Du darfst spaeter weiterhin Konstruktoren nutzen. Du brauchst noch kein Interface.
Ist noch ein leerer Truck offen, fuege das Kind-horn hinzu, das honk druckt, bevor du den Bildschirm bewertest. Ist noch eine Konstruktordatei offen, wechsle zur Ueberschreiben-Datei, damit t.horn() der Aufruf unter Test ist. Die neuen Tokens sind die neu geschriebene Methode auf dem Kind und die zwei unterschiedlichen Bildschirmwoerter beep und honk.
Vor Interfaces
Du kannst horn auf Truck neu schreiben und honk von t.horn() sehen. Du kannst sowohl c.horn() als auch t.horn() aufrufen und beep dann honk sehen. Kompiliere Yard.java und starte java Yard fuer jede behaltene Demo der Reihe nach. Der Kindkoerper antwortete auf den Truck-Aufruf. Die naechste Seite sind Interfaces, wo ein Typ Methoden versprechen kann, ohne allein auf extends zu setzen.
Behalte die Ein-Truck-honk-Demo fuer klares Ueberschreiben. Behalte die Zwei-Objekt-Demo fuer klaren Eltern-versus-Kind-Kontrast. Halte Interface-Dateien von dieser Seite fern. Diese drei Gewohnheiten sind der Checkpoint vor dem Weitergehen. Wenn honk nach t.horn() erscheint und beep nach c.horn() noch erscheint, hat Ueberschreiben seine Arbeit fuer diese Lektion getan und du bist bereit fuer das naechste Thema ueber Interfaces.
Ein letzter Ordner-Durchgang: ein oeffentliches Yard, zwei Hilfstypen, ein Kind-horn, das honk druckt, kein Tastaturwarten, kein erzwungenes Interface. Starte javac Yard.java und java Yard noch einmal auf der offenen Demo. Wenn der Bildschirm noch zur Tabelle passt — Eltern beep, Kind honk — ist das Ueberschreiben fest und der Kurs kann auf der naechsten Seite zu Interfaces gehen.
🧠 Testen Sie Ihr Wissen
Testen Sie Ihr Wissen
Fordern Sie sich mit diesem interaktiven Quiz heraus und sehen Sie, wie gut Sie das Thema verstehen
📝 Anweisungen
- Lesen Sie jede Frage sorgfältig
- Wählen Sie die beste Antwort für jede Frage
- Sie können das Quiz so oft wiederholen, wie Sie möchten
- Ihr Fortschritt wird oben angezeigt