Java 7 Grundkurs

Schnittstellen (interfaces)

LinkedIn Learning kostenlos und unverbindlich testen!

Jetzt testen Alle Abonnements anzeigen
Interfaces (oder Schnittstellen) entkoppeln Klassen und machen sie unabhängig voneinander. Sehen Sie im Video den Weg vom Problem zur Lösung im Beispiel des "Aufsteh-Helfers".
08:59

Transkript

Interfaces machen es möglich, Schnittstellen separat von Klassen zu deklarieren. Schauen wir uns mal in einem Beispiel an, wozu wir das brauchen können. Wir haben in unserem Haushalt diverse technische Gerätschaften, u.a. ein richtiges altmodisches Radio, eine Tischlampe und eine Kaffeemaschine. Mit diesen Geräten kann man verschiedene Dinge tun. Das Radio kann man z. B. einschalten und ausschalten, man kann den Sender wählen und die Lautstärke einstellen. Die Lampe kann einfach nur an und aus gemacht werden. Die Kaffeemaschine kann man einschalten, man kann Wasser nachfüllen, Filter einsetzen, Kaffee einfüllen usw., und man kann sie natürlich auch wieder ausschalten. Nun ist es manchmal am Morgen, wenn man noch nicht so ganz wach ist, recht schwierig, all diese Geräte der Reihe nach einzuschalten. Die Schalter sind zu klein oder auch sehr versteckt angebracht. Deswegen bauen wir uns einen Easy Morning Aufsteh-Helfer, der einen großen, gut zu findenden Knopf hat, zum Einschalten aller Geräte, und einen etwas kleineren zum Ausschalten aller Geräte. Dazu muss er natürlich alle Geräte kennen, das heißt, er muss nicht nur wissen, wo sie sich befinden, sondern er muss auch ihre Typen kennen. Unser Easy Morning Aufsteh-Helfer hält also hier drei Attribute vor, eins fürs Radio, eins für die Lampe und eins für die Kaffeemaschine. In der Einschalt-Methode kann er nun zu jedem dieser Geräte hingehen und es einschalten, in der Ausschalt-Methode entsprechend alle Geräte ausschalten. Von der Sache her wahrscheinlich schon nicht schlecht, aber unser Easy Morning Aufsteh-Helfer ist sehr abhängig von all unseren Geräten. Er muss sie alle genau kennen. Nun überlegen wir zurzeit, ob wir uns nicht demnächst einen Fernseher zulegen möchten. Sollte es dazu kommen, dann müssten wir unseren Easy Morning Aufsteh-Helfer anpassen und entsprechend aktualisieren, denn die Klasse "Fernseher" kennt er ja noch nicht, und demzufolge kann er auch keinen Fernseher einschalten oder ausschalten. An ein Array oder eine Liste ist ja hier nicht zu denken, weil das ja alles unterschiedliche Typen sind. Also vergessen wir das mit dem Fernseher am besten erst mal wieder. Was den Easy Morning Aufsteh-Helfer eigentlich nur interessiert, sind die Methoden "An" und "Aus" in den einzelnen Klassen. Die Klassen selbst interessieren ihn eigentlich überhaupt nicht. Er muss nicht wissen, ob es ein Radio ist, eine Lampe oder eine Kaffeemaschine. Das heißt, wir müssen jetzt am besten die beiden Methoden "An" und "Aus" aus diesen Klassen herauslösen und separat in einem eigenen Typ deklarieren. Genau das machen wir mit einem Interface. Ein Interface bekommt einen Namen, genauso wie eine Klasse, und ich kann dort auch Methoden deklarieren. Was ich nicht machen kann, ist die Methoden implementieren. Ich lege im Interface also lediglich fest, wie die Methoden heißen sollen, was für Parametertypen sie haben möchten und was sie gern zurückgeben. Ich beschränke mich also auf den Teil der Methode, den man von außen sehen kann. Für jemanden, der diese Methoden aufrufen möchte, ist das auch vollkommen ausreichend. Wenn nun unsere Geräte diese Schnittstelle, dieses Interface anbieten, dann bedeutet das, dass sie diese Methoden haben, die in dem Interface deklariert sind. Ein Easy Morning Aufsteh-Helfer, der nur das Interface kennt, kann also diese Methoden aufrufen. Mit der Deklaration unseres Interfaces "Schaltbar" deklarieren wir obendrein einen eigenen Typ. Wenn also z. B. unser Radio dieses Interface "Schaltbar" anbietet, dann kann ich es also Radio betrachten, das heißt, ich kann einen Sender wählen, lauter/leiser stellen, oder ich kann es als "Schaltbar" betrachten, dann kann ich es nur an- oder ausschalten. Auf diese Weise kann ich alle meine Geräte über denselben Typ ansprechen, nämlich über den Typ des Interfaces "Schaltbar". Unser Easy Morning Aufsteh-Helfer kann nun also eine Liste anlegen, in die Schaltbar-Objekte rein dürfen, und alle Objekte, die dieses Interface anbieten, können in die Liste. Wenn ich mir nun eines Tages doch noch einen Fernseher kaufen sollte, dann muss ich lediglich dafür sorgen, dass auch der dieses Interface anbietet, und ich kann ihn problemlos bei meinem Easy Morning Aufsteh-Helfer anmelden, ohne dass ich diesen dafür irgendwie ändern muss. Jetzt schauen wir uns das mal im Quelltext an. Die Deklaration eines Interfaces beginnt sehr ähnlich zu der Deklaration einer Klasse, nur dass hier eben nicht das Schlüsselwort "Class" steht, sondern "Interface". Im Interface deklariere ich nun die Methodenköpfe, ohne geschweifte Klammern dahinter, also ohne Implementierung, nur mit einem Semikolon hinten dran. Ich will nur die Schnittstelle festlegen, nicht die Implementierung. Nicht umsonst heißt das Ding "Interface". Methoden, die ich in einem Interface deklariere, müssen grundsätzlich "Public" sein. Was anderes geht nicht, dann gibt es einen Compiler-Fehler. In abstrakten Klassen können wir auch solche Methoden deklarieren, da steht hier davor noch das Schlüsselwort "Abstract". In der Tat besteht ein Interface grundsätzlich aus abstrakten Methoden, und zwar sogar so grundsätzlich, dass ich das "Abstract" sogar weglassen darf und die Methode trotzdem abstrakt ist. Nun haben wir gesehen, wie das Interface aussieht. Schauen wir uns mal eines der Geräte an. Nehmen wir mal das Radio. Die Klasse Radio sagt hier oben, dass sie das Interface "Schaltbar" anbietet. Das ist eine verbindliche Äußerung, und das bedeutet, dass jeder, der dieses Interface kennt, alle Methoden am Radio aufrufen kann, die in diesem Interface deklariert sind. Wenn ich aufs Interface draufklicke, dann sehen wir auch an den farblichen Markierungen, welche Methoden das sind. Bei den anderen Klassen sieht das dann genau so aus. Tischlampe implement "Schaltbar", wir haben hier auch die beiden Methoden "An" und "Aus", und in der Kaffeemaschine genau das gleiche: "An" und "Aus". Mit dieser Deklaration "Klasse implementiert Schnittstelle" macht die Klasse also die feste Zusage, dass sie alle Methoden anbietet, die in der Schnittstelle drin stehen. Aber was ist, wenn wir eine der Methoden vergessen zu implementieren? Mache ich das mal, nehme ich die hier raus. Sie haben es vielleicht schon vermutet — Compiler-Fehler. Der Compiler kennt das Interface, der Compiler weiß, welche Methoden drin stehen, und er passt auf, dass keine Klasse behauptet, das Interface zu implementieren, wenn es gar nicht stimmt. Also machen wir das schnell wieder rückgängig: Kringellinie wieder weg. Damit kommen wir zum Grund, zum Auslöser dieser ganzen Geschichte, zu unserem Easy Morning Aufsteh-Helfer. Der deklariert hier erst mal eine Variable "Geräte", ein Attribut, das ist eine Liste aus "Schaltbar"-Objekten. "Schaltbar" ist ja ein Typ, so wie eine Klasse auch, also kann ich auch eine Liste davon anlegen. In diese Liste dürfen dann natürlich nur Objekte, die auch diese Schnittstelle anbieten. Im Konstruktor wird die Liste dann erzeugt. Damit kommen wir zu den beiden wichtigsten Methoden, nämlich "Einschalten" und "Ausschalten". Die Einschalten-Methode gibt eine kurze Statusmeldung ab, dann iteriert sie einfach durch die Liste, holt sich der Reihe nach die Geräte raus, und ruft von jedem Gerät die Methode "an" auf. "an" ist in unserem Interface "Schaltbar" deklariert. Die Liste kann nur Schaltbar-Objekte enthalten, also haben alle Objekte in der Liste diese Methode. Was sie dann tut, das hängt natürlich davon ab, was es konkret für ein Objekt jeweils ist. Die "Ausschalten"-Methode sieht dann prinzipiell genauso aus, nur dass hier steht "Helfer schaltet alle Geräte aus", und da die Liste ja zu Anfang leer ist, müssen wir sie noch irgendwie befüllen können. Dafür gibt es dann hier unten noch die Methode "Gerät hinzufügen". Auch diese Methode akzeptiert wiederum nur ein Schaltbar-Gerät. Hier haben wir die Methode "Gerät entfernen", auch die nimmt nur ein Schaltbar-Gerät und entfernt es dann aus der internen Liste. Jetzt müssen wir das Ganze natürlich wenigstens ansatzweise ausprobieren. Dafür habe ich hier die Main-Klasse. In der Main-Methode werden zuerst einmal die Geräte gekauft, also ein Radio, eine Lampe, eine Kaffeemaschine, dann baue ich mir mein Easy Morning Aufsteh-Helfer, und jetzt mache ich ihn mit den Geräten bekannt. Dazu rufe ich der Reihe nach "Gerät hinzufügen" auf, jedes Mal mit einem anderen der Objekte, und schließlich kommt der Testmoment. Ich sage: "Helfer einschalten". Führen wir das mal aus. Dann steht hier: "Helfer schaltet alle Geräte an", und zwar: Radio ist an, Lampe ist an, Kaffeemaschine ist an. Der wesentliche Effekt, den wir hier mit der Einführung des Interfaces erreichen, ist dass wir unseren Easy Morning Aufsteh-Helfer entkoppeln von all unseren konkreten Geräten. Er muss deren Typen nicht mehr kennen, und ich kann später noch beliebige weitere Geräte hinzufügen, wie z. B. den Fernseher, ohne dass ich den Easy Morning Aufsteh-Helfer dafür ändern muss. Nun kann eine Klasse aber nicht nur ein Interface anbieten, sondern auch mehrere. Es wäre also hier in diesem Beispiel denkbar, dass wir uns ein weiteres Interface überlegen, nämlich "Multimedia"; darin stehen die Methoden "Lauter", "Leiser", und "Sender wählen". Sowohl Fernseher als auch Radio implementieren dieses Interface, bieten also die entsprechenden Methoden an. Dann könnte ich mir eine Universalfernbedienung kaufen, die wieder nur das Interface kennt, und könnte mit dieser Fernbedienung sowohl Fernseher als auch Radio steuern. Sollte ich dann irgendwann das Radio z. B. durch einen MP3-Player ersetzen, dann wird dieser vermutlich auch wieder das Interface "Multimedia" anbieten, und ich kann meine Fernbedienung weiter benutzen. Wenn eine Klasse deklarieren möchte, dass sie mehrere Interfaces anbietet, dann zählt sie die einfach der Reihe nach auf hinter dem Schlüsselwort "Implements" und trennt sie durch Kommas. Damit haben Sie nun gesehen, was Interfaces sind, und wie Sie sie verwenden können, um Klassen voneinander zu entkoppeln und unabhängig voneinander zu machen.

Java 7 Grundkurs

Machen Sie sich mit den Grundlagen der Java-Programmierung vertraut und lernen Sie die Syntax der Sprache sowie das Konzept der objektorientierten Softwareentwicklung kennen.

8 Std. 32 min (66 Videos)
Derzeit sind keine Feedbacks vorhanden...

Dieser Online-Kurs ist als Download und als Streaming-Video verfügbar. Die gute Nachricht: Sie müssen sich nicht entscheiden - sobald Sie das Training erwerben, erhalten Sie Zugang zu beiden Optionen!

Der Download ermöglicht Ihnen die Offline-Nutzung des Trainings und bietet die Vorteile einer benutzerfreundlichen Abspielumgebung. Wenn Sie an verschiedenen Computern arbeiten, oder nicht den ganzen Kurs auf einmal herunterladen möchten, loggen Sie sich auf dieser Seite ein, um alle Videos des Trainings als Streaming-Video anzusehen.

Wir hoffen, dass Sie viel Freude und Erfolg mit diesem Video-Training haben werden. Falls Sie irgendwelche Fragen haben, zögern Sie nicht uns zu kontaktieren!