Interfaces in Java
Deklariere ein interface mit leeren Methodenkoepfen, dann fuelle diese Methoden in einer Klasse mit implements. Schreibe interface Signal mit void horn(); und ohne Koerper. Schreibe class Truck implements Signal und gib horn einen Koerper, der 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 laesst eine Klasse zwei Interfaces zugleich implements. Lass Enums fuer die naechste Seite — diese Lektion ist das Versprechen einer Methode und die Klasse, die es haelt.
Implementiere eine Interface-Methode
Die Ueberschreiben-Seite schrieb horn auf einem Kind neu, das schon extends Car hatte. Diese Seite startet von einem Versprechen ohne Koerper. Oeffne Yard.java. Halte den oeffentlichen Klassennamen Yard. Loesche uebrige Car/Truck-extends-Demos, wenn sie die Interface-Geschichte begraben, uebrige Konstruktor-super-Drucke, Pfaddemos und Tastatur-Scanner. Das Programm darf nicht auf Tippen warten. Du brauchst keine Importzeile.
Deklariere das Interface oberhalb der Klassen:
interface Signal {
void horn();
}
Der Kopf endet mit einem Semikolon. Innerhalb des Interface gibt es in dieser Anfaengerform keinen { }-Koerper fuer horn.
Deklariere die Klasse, die das Versprechen haelt:
class Truck implements Signal {
In Truck schreibst du eine public-Methode mit demselben Namen und fuellst den Koerper:
public void horn() {
System.out.println("honk");
}
Das Schluesselwort ist implements, nicht extends. Die Klasse muss fuer jede auf dem Interface gelistete Methode einen Koerper liefern. Auf dieser Seite ist das nur 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.
interface Signal {
void horn();
}
class Truck implements Signal {
public 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. Das Interface Signal und die Hilfsklasse 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, der Signal versprochen hat. t.horn() laeuft den Koerper auf Truck und druckt honk. Du schreibst nie new Signal() — das Interface nennt die Methoden; die Klasse liefert die Koerper und das Objekt.
Wenn javac ablehnt, pruefe drei Dinge. Erstens muss die Klassenzeile implements Signal sagen, nicht extends Signal. Zweitens braucht jede Interface-Methode eine passende Methode auf der Klasse. Drittens ist die Implementierungsmethode in dieser Lehrform public, damit sie dem oeffentlichen Vertrag des Interface entspricht. Siehst du noch beep aus einer alten Override-Datei, wechsle zur Interface-Lehrdatei und starte java Yard erneut.
Sag die Regel laut, waehrend du den Bildschirm siehst: Interface nennt den Aufruf, Klasse fuellt den Koerper, Objekt laeuft diesen Koerper. Halte implements auf der Klasse, die den Druck besitzt. Erfinde auf dieser Seite kein enum. Enums warten auf die naechste Lektion.
Implementiere zwei Interfaces auf einer Klasse
Ein zweites Programm behält Yard und Truck. Jetzt implementiert Truck zwei Interfaces. Signal verlangt weiter horn. Mark verlangt show. Die Klasse fuellt beide Koerper. main ruft beide Methoden auf.
interface Signal {
void horn();
}
interface Mark {
void show();
}
class Truck implements Signal, Mark {
public void horn() {
System.out.println("honk");
}
public void show() {
System.out.println("truck");
}
}
public class Yard {
public static void main(String[] args) {
Truck t = new Truck();
t.horn();
t.show();
}
}
Kompiliere mit javac Yard.java, dann starte java Yard. Der Bildschirm zeigt honk, dann truck. Die erste Zeile kommt vom Signal-Versprechen, gefuellt auf Truck. Die zweite Zeile kommt vom Mark-Versprechen, gefuellt auf derselben Klasse. Trenne Interface-Namen in der implements-Liste mit Komma: implements Signal, Mark.
Lies den Klassenkopf noch einmal. Eine Klasse. Zwei Interfaces. Zwei Methodenkoerper. Das ist das Anfaengerbild, mehr als ein Versprechen zu halten, ohne zwei extends-Eltern. Java erlaubt einer Klasse, nur eine Klasse zu erweitern; sie kann mehrere Interfaces implementieren. Diese Seite zeigt diese Kommaliste in einer kleinen Yard-Datei.
Wenn du show weglasst, waehrend Mark gelistet ist, lehnt javac ab, weil jede gelistete Interface-Methode einen Koerper braucht. Wenn du Mark aus der implements-Liste laesst, aber trotzdem show schreibst, hast du eine gewoehnliche Methode, keine Interface-Erfuellung fuer Mark. Halte beide Namen auf der Klassenzeile, wenn du beide Versprechen geprueft haben willst.
Vergleich mit extends-Ueberschreiben
Auf der Ueberschreiben-Seite machte Truck extends Car und schrieb horn neu, das schon einen Elternkoerper hatte. Auf dieser Seite startet Signal ohne Koerper, und Truck implements Signal liefert den ersten Koerper. Du kompilierst weiter Yard.java und startest java Yard. Du rufst weiter t.horn() auf. Die neuen Tokens sind interface, implements und — in der zweiten Demo — eine komma-getrennte implements-Liste.
Wenn eine uebrige Override-Datei noch offen ist, siehst du extends Car und vielleicht beep neben honk. Wechsle zur Interface-Lehrdatei, damit oben interface Signal steht und die Klassenzeile implements zeigt. Halte Enum-Demos von dieser Seite fern. Halte Tastatureingabe von dieser Seite fern.
Was diese Seite fuer Enums laesst
Diese Seite fuellt Interface-Methoden mit implements. Die naechste Seite zeigt Enums, wo ein Typ eine feste Menge benannter Werte listet. Bleib hier bei Interface-Versprechen. Ersetze die heutigen Demos noch nicht durch eine enum-Liste als Pflicht.
Wenn du spaeter Enums nutzt, kannst du auf anderen Typen im selben Programm weiter Interfaces implementieren. Behandle diese Seite als Interface-Haelfte jener Nachbargeschichte. Beende beide Yard-Demos, bis honk — und dann honk plus truck — automatisch wirken, bevor du die Enum-Lektion oeffnest.
Vor Enums
Du kannst interface Signal mit leerem horn() schreiben, es auf Truck implementieren und honk von t.horn() sehen. Du kannst Signal und Mark auf einer Klasse implementieren und honk dann truck sehen. Kompiliere Yard.java und starte java Yard fuer jede behaltene Demo. Die Klasse hielt die Interface-Versprechen. Die naechste Seite ist Enums, wo ein Typ feste Namen listet.
Behalte die Ein-Interface-honk-Demo fuer eine klare implements-Geschichte. Behalte die Zwei-Interface-Demo fuer eine klare Kommaliste. Halte Enum-Dateien von dieser Seite fern. Diese drei Gewohnheiten sind der Checkpoint vor dem Weitergehen. Wenn honk nach t.horn() erscheint — und wenn die zweite Demo nach show() auch truck druckt — haben Interfaces ihren Job fuer diese Lektion getan und du bist bereit fuer das naechste Thema ueber Enums.
Ein letzter Blick durch den Ordner: ein oeffentliches Yard, Interface-Koepfe mit leeren Methoden, eine Klasse die sie implements, kein Tastaturwarten, kein erzwungenes enum. Starte javac Yard.java und java Yard noch einmal auf der offenen Demo. Wenn der Bildschirm noch die Interface-Fuellungen druckt, die du geschrieben hast, sind die Versprechen solid und der Kurs kann auf der naechsten Seite zu Enums 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