super in Java

Nutze super im Kindkonstruktor, damit der Elternkonstruktor zuerst laeuft. Behalte Truck extends Car. In Truck() rufst du super(); auf und druckst danach truck. In Car() druckst du car. Kompiliere Yard.java und starte java Yard. Der Bildschirm soll car, dann truck zeigen. Eine zweite Demo uebergibt eine Marke mit super("car") an Car(String mark). Lass das Ueberschreiben einer Methode fuer die naechste Seite — diese Lektion geht um Konstruktorreihenfolge mit super.

Rufe zuerst den Elternkonstruktor auf

Die Vererbungsseite liess einen leeren Truck die Methode horn von Car nutzen. Diese Seite fuegt Konstruktoren hinzu. Oeffne Yard.java. Halte den oeffentlichen Klassennamen Yard. Loesche uebrige Pfaddemos, nur-horn-Dateien falls sie die Konstruktoren verwirren, Store-Schreiber und Tastatur-Scanner. Das Programm darf nicht auf Tippen warten. Du brauchst keine Importzeile.
Deklariere das Elternteil mit einem argumentlosen Konstruktor, der car druckt:
class Car {
Car() {
System.out.println("car");
}
}
Deklariere das Kind mit extends Car. In Truck() ist super(); die erste Anweisung, danach druckst du truck:
super();
System.out.println("truck");
In Yard.main baust du einen Truck:
Truck t = new Truck();
Das Bauen des Trucks betritt Truck(). Dieser Aufruf beginnt mit super() und laeuft Car(). Nach dem Elternteil laeuft der Kind-Druck.

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 car, dann truck. Geh den Lauf einmal durch. Java startet bei Yard.main. new Truck() betritt Truck(). Die erste Anweisung ist super();, also laeuft Car() und druckt car. Die Kontrolle kehrt zu Truck() zurueck und druckt truck. Die Elternzeile erscheint vor der Kindzeile, weil super() zuerst lief.
Sag die Reihenfolge laut, waehrend du den Bildschirm siehst: Elternkonstruktor, dann Kind-Druck. Diese gesprochene Ordnung passt zu dem, was super() im Kindkonstruktor erzwingt. Kommen die Zeilen in falscher Folge, oeffne die Lehrdatei erneut und pruefe, dass super(); noch die erste Anweisung in Truck() vor jedem println ist.
Wenn du in einem spaeteren Experiment, in dem der Elternkonstruktor Argumente braucht, truck vor super() druckst, kann javac ablehnen — super muss die erste Anweisung sein, wenn du es schreibst. In der ersten Demo braucht das Elternteil keine Argumente, und die Lehrdatei haelt super(); absichtlich zuerst, damit die Ordnung klar bleibt. Siehst du nur beep aus einer alten horn-Demo, wechsle zur Konstruktor-Lehrdatei und starte java Yard erneut.
Schreibe horn auf dieser Seite nicht auf Truck neu. Methoden ueberschreiben ist die naechste Lektion. Heute spricht der Kindkonstruktor mit dem Elternteil ueber super und druckt danach sein eigenes Wort. Halte das Wort car auf der Elternseite und truck auf der Kindseite, damit jede Zeile sagt, welcher Konstruktor fertig ist.

Uebergib dem Elternteil einen Wert mit super

Ein zweites Programm behält extends. Der Elternkonstruktor nimmt jetzt ein String mark und druckt diese Marke. Das Kind ruft super("car") auf und druckt danach truck.

Kompiliere mit javac Yard.java, dann starte java Yard. Der Bildschirm zeigt wieder car, dann truck. Diesmal ist car das Argument, das du durch super("car") uebergibst, kein fest verdrahteter Druck in einem argumentlosen Car(). Das Kind waehlte die Markenzeichenkette; der Elternkonstruktor druckte sie. Danach druckte das Kind truck.
Lies die Elternkonstruktor-Signatur noch einmal: Car(String mark). Die Zeichenkette in Anfuehrungszeichen in super("car") ist diese Marke. Aendere fuer diesen Check sonst nichts in der Datei — behalte extends Car, behalte den Kind-Druck von truck, und behalte new Truck() in main. Der Bildschirm endet weiterhin mit truck unter car, weil der Kind-Druck erst nach der Rueckkehr von super("car") laeuft.
Laesst du super("car") weg, waehrend Car nur Car(String mark) hat, lehnt javac ab, weil das Elternteil keinen stillen argumentlosen Konstruktor mehr hat, den es fuer dich aufrufen koennte. Der passende super(...)-Aufruf ist, wie das Kind das Elternteil mit den noetigen Werten startet. Halte super als erste Anweisung in Truck(). Beschwert sich javac ueber einen fehlenden Standardkonstruktor auf Car, schau zuerst in den Kindkonstruktor und bestaetige, dass die Zeile super("car") da ist und noch zuerst steht.

Vergleich mit plain extends auf der horn-Seite

Auf der Vererbungsseite rief ein leerer Truck horn auf, ohne Konstruktoren zu schreiben. Auf dieser Seite laufen Konstruktoren in Reihenfolge ueber super. Behalte horn-Demos als Geschichte, wenn sie noch in der Naehe liegen; starte die super-Lehrdatei mit java Yard, damit der Bildschirm car dann truck zeigt.
Die horn-Seite zeigte, dass extends eine Methode teilt. Diese Seite zeigt, dass extends auch einen Bauweg teilt: das Kind startet das Elternteil ueber super und setzt mit dem eigenen Druck fort. Beide Lektionen behalten Truck extends Car. Nur der Koerper von Truck aendert sich — von leeren Klammern mit spaeterem horn-Aufruf zu einem Konstruktor, der mit super beginnt.
super(), super("car") und Konstruktorreihenfolge sind die neuen Token. Du brauchst weiterhin extends. Du musst noch keine Methode ueberschreiben. Sitzt noch ein uebriger horn-Aufruf in main, entferne ihn fuer diese Demos, damit der Bildschirm nur die Konstruktordrucke zeigt.

Was diese Seite fuers Ueberschreiben laesst

Diese Seite startet Elternkonstruktoren mit super. Die naechste Seite zeigt Ueberschreiben, wo ein Kind seine eigene Version einer Methode schreibt, die das Elternteil schon hat. Bleib hier bei Konstruktor-super-Aufrufen. Ersetze horn auf Truck in diesen Demos noch nicht als Pflicht.
Wenn du spaeter eine Methode ueberschreibst, wirst du oft trotzdem zuerst einen Elternkonstruktor mit super aufrufen. Behandle diese Seite als die Konstruktorhaelfte dieser Geschichte. Beende beide Yard-Demos, bis car dann truck selbstverstaendlich wirkt, bevor du die Ueberschreiben-Lektion oeffnest.

Vor dem Ueberschreiben

Du kannst super(); aufrufen, dann truck drucken und zuerst car sehen. Du kannst super("car") aufrufen, wenn das Elternteil eine Marke nimmt, und trotzdem car, dann truck sehen. Kompiliere Yard.java und starte java Yard fuer jede behaltene Demo der Reihe nach. Der Elternkonstruktor endete vor dem Kind-Druck. Die naechste Seite ist Ueberschreiben, wo das Kind einen Methodenkoerper ersetzt.
Behalte die argumentlose super()-Demo fuer klare Ordnung. Behalte die super("car")-Demo fuer klare Argumentuebergabe. Halte Methoden-Override von dieser Seite fern. Diese drei Gewohnheiten sind der Checkpoint vor dem Weitergehen. Wenn car nach new Truck() ueber truck erscheint, hat super seine Arbeit fuer diese Lektion getan und du bist bereit fuer das naechste Thema Ueberschreiben.
Ein letzter Blick in den Ordner: ein oeffentliches Yard, zwei Hilfstypen, kein Tastaturwarten, keine Pfadreste, kein erzwungenes horn-Neu schreiben. Starte javac Yard.java und java Yard noch einmal auf der offenen Demo. Wenn der Bildschirm noch car dann truck druckt, steht die Konstruktorordnung und der Kurs kann auf der naechsten Seite zum Ueberschreiben gehen.