Polymorphie in Java
Speichere unterschiedliche Objekte in einer eltern-typisierten Variable, damit ein Aufrufname verschiedene Koerper laufen lassen kann. Behalte horn auf Machine so, dass tone gedruckt wird. Auf Truck schreibe horn um, damit honk gedruckt wird. Auf Car schreibe horn um, damit beep gedruckt wird. In Yard.java weise Machine m = new Machine();, Machine t = new Truck(); und Machine c = new Car(); zu und rufe dann auf jedem horn auf. Kompiliere mit javac Yard.java und starte java Yard. Der Bildschirm soll tone, dann honk, dann beep zeigen. Eine zweite Demo haelt nur die beiden Kinder als Machine-Referenzen. Lass equals fuer die naechste Seite — diese Lektion ist ein Elterntyp, der viele Formen haelt.
Ein Elterntyp, drei horn-Koerper
Die abstract-Seite liess eine Methode unfertig, damit Kinder sie fuellen. Diese Seite fokussiert den Aufruf durch eine eltern-typisierte Variable. Oeffne Yard.java. Halte den oeffentlichen Klassennamen Yard. Loesche uebrige abstract-only-Demos, wenn sie die eltern-typisierte Geschichte begraben, uebrige enum Level-Dateien, Pfaddemos und Tastatur-Scanner. Das Programm darf nicht auf Tippen warten. Du brauchst keine Importzeile.
Deklariere einen normalen Elternteil mit einem horn-Koerper:
class Machine {
void horn() {
System.out.println("tone");
}
}
Deklariere Kinder mit extends Machine und eigenen horn-Koerpern, die honk und beep drucken. Gleicher Name und leere Parameterliste bedeuten, dass jedes Kind die Elternmethode ueberschreibt.
In Yard.main baue drei Variablen, deren deklarierter Typ Machine ist:
Machine m = new Machine();
Machine t = new Truck();
Machine c = new Car();
Dann rufe auf:
m.horn();
t.horn();
c.horn();
Der deklarierte Typ ist fuer alle drei Machine. Das echte Objekt entscheidet, welcher horn-Koerper laeuft.
class Machine {
void horn() {
System.out.println("tone");
}
}
class Truck extends Machine {
void horn() {
System.out.println("honk");
}
}
class Car extends Machine {
void horn() {
System.out.println("beep");
}
}
public class Yard {
public static void main(String[] args) {
Machine m = new Machine();
Machine t = new Truck();
Machine c = new Car();
m.horn();
t.horn();
c.horn();
}
}
Aus dem Ordner mit Yard.java starte javac Yard.java. Wenn Klammern, geschweifte Klammern und Semikolons passen, schreibt javac keine eigene Zeile. Dann starte java Yard — nicht java Yard.java. Lass die Endung .java beim Laufbefehl weg. Halte eine oeffentliche Klasse in der Datei, damit der Name zu Yard passt. Hilfstypen bleiben ohne public in dieser Anfaengerform.
Der Bildschirm zeigt tone, dann honk, dann beep. Geh den Lauf einmal durch. Java startet bei Yard.main. m haelt eine normale Machine, also druckt m.horn() tone. t haelt einen Truck, auch wenn der Variablentyp Machine sagt, also druckt t.horn() honk. c haelt einen Car, also druckt c.horn() beep. Gleiche Aufrufschreibweise. Drei Koerper.
Zeige auf jede Zuweisung, waehrend du die passende Bildschirmzeile liest. Die erste Zeile gehoert zur normalen Machine. Die zweite Zeile gehoert zum Truck-Objekt hinter einem machine-typisierten Namen. Die dritte Zeile gehoert zum Car-Objekt hinter einem machine-typisierten Namen. Dieses Zuordnungsspiel ist die ganze Lektion in einem Durchgang.
Wenn du noch nur honk dann park aus einer abstract-Demo siehst, wechsle zur Polymorphie-Lehrdatei und starte java Yard erneut. Wenn jede Variable nur als Truck oder Car typisiert ist, zeigst du die eltern-typisierte Form dieser Seite noch nicht — halte den Typ Machine links an den Zuweisungen fuer die Demo.
Sag die Regel laut, waehrend du den Bildschirm siehst: Variablentyp kann der Elternteil sein, Objekt kann das Kind sein, der Aufruf laeuft den Kindkoerper, wenn das Kind die Methode ueberschrieben hat. Erfinde auf dieser Seite keinen equals-Override. Das Thema wartet auf die naechste Lektion.
Zwei Kinder ueber Machine-Referenzen
Ein zweites Programm behaelt die Overrides. main baut nur Truck und Car, speichert sie weiterhin als Machine und ruft auf jedem horn auf.
class Machine {
void horn() {
System.out.println("tone");
}
}
class Truck extends Machine {
void horn() {
System.out.println("honk");
}
}
class Car extends Machine {
void horn() {
System.out.println("beep");
}
}
public class Yard {
public static void main(String[] args) {
Machine t = new Truck();
Machine c = new Car();
t.horn();
c.horn();
}
}
Kompiliere mit javac Yard.java, dann starte java Yard. Der Bildschirm zeigt honk, dann beep. In dieser zweiten Demo gibt es kein normales Machine-Objekt, und doch sind beide Variablen noch als Machine typisiert. Die Kindobjekte liefern die Koerper. Dieselbe Polymorphie-Idee mit kuerzerem Bildschirm.
Lies die Zuweisungszeilen noch einmal: links Machine, rechts new Truck() oder new Car(). Die linke Seite nennt den Elterntyp, durch den du aufrufst. Die rechte Seite nennt das echte Objekt. Halte extends Machine auf beiden Kindern, damit diese Zuweisungen legal bleiben.
Wenn abstract-Demos noch in der Naehe liegen, behalte sie als Geschichte. Fuer diese Lektion starte die Polymorphie-Lehrdatei, damit der Bildschirm tone / honk / beep oder honk / beep zeigt, nicht park als Hauptgeschichte. Wenn javac ueber doppelte oeffentliche Klassen klagt, halte nur Yard oeffentlich.
Welcher horn-Koerper laeuft
📊 Who runs for each Machine variable
| Variable | Real object | horn prints |
|---|---|---|
m |
Machine |
tone |
t |
Truck |
honk |
c |
Car |
beep |
Verglichen mit abstract-Fuellungen
Auf der abstract-Seite liess Machine horn unfertig und Kinder fuellten es, oft mit gemeinsamem park. Auf dieser Seite hat Machine bereits einen tone-Koerper, Kinder ueberschreiben ihn, und eltern-typisierte Variablen halten die Objekte. Du kompilierst weiterhin Yard.java und startest java Yard. Die neuen Tokens sind eltern-typisierte Zuweisungen wie Machine t = new Truck(); und die drei verschiedenen Drucke von einem Aufrufnamen.
Wenn eine abstract-Datei noch offen ist, siehst du vielleicht abstract void horn(); und park. Wechsle zur Polymorphie-Datei, damit Machine einen normalen horn-Koerper hat und main Machine-Variablen verschiedenen Objekten zuweist. Halte equals-Demos von dieser Seite fern. Halte Tastatureingabe von dieser Seite fern.
Vor equals
Du kannst Machine-Variablen Machine-, Truck- und Car-Objekten zuweisen und tone, dann honk, dann beep sehen. Du kannst nur die beiden Kinder als Machine-Referenzen halten und honk dann beep sehen. Kompiliere Yard.java und starte java Yard fuer jede behaltene Demo nacheinander. Der Aufruf nutzte den Besitzer des Koerpers. Die naechste Seite ist equals, wo zwei Objekte lehrsicher auf Gleichheit verglichen werden.
Behalte die Drei-Objekt-Demo fuer einen klaren Eltern-plus-Kinder-Bildschirm. Behalte die Zwei-Kinder-Demo fuer ein klares eltern-typisiertes Paar. Halte equals-Dateien von dieser Seite fern. Diese drei Gewohnheiten sind der Checkpoint vor dem Weitergehen. Wenn honk aus einer Machine-typisierten Truck-Variable kommt, hat Polymorphie die Arbeit dieser Lektion erledigt und du bist bereit fuer das naechste Thema ueber equals.
Ein letzter Blick durch den Ordner: ein oeffentliches Yard, Eltern- und Kind-horn-Koerper, eltern-typisierte Variablen in main, kein Tastaturwarten, kein erzwungenes equals. Starte javac Yard.java und java Yard noch einmal auf der offenen Demo. Wenn der Bildschirm noch zur Tabelle passt, ist der Viele-Formen-Aufruf solide und der Kurs kann auf der naechsten Seite zu equals wechseln.
🧠 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