Im zweiten Abschnitt hatten wir darüber gesprochen, dass Events verwendet werden,
um diese grafischen Beeignisse über die grafischen Ölnutzeroberschläche zu verarbeiten.
Und jetzt möchte ich mir einführen, dass das mittels Listener passiert.
Eben viel schönes Stichwort, Entwurfsmuster, Beobachter mit dieser Publishing-Subscribe.
Genau da machen wir weiter. Folie 20 schließt sich an das,
was wir vorher gesagt hatten, an. Diese Ereignisse,
die an der Oberfläche ausgelöst werden, ich zeige nochmal eine Folie zurück.
Hier waren wir gerade, ja. Also diese Ereignisse,
Events, diese Ereignisse lösen werden vom Benutzer auf der Oberfläche ausgelöst durch seine Interaktionen.
Und dann kann die Applikation reagieren, ja,
reaktive Software kann reagieren und das machen wir mittels Listener.
Listener sind die Dinge, das auf Deutsch, das der Zuhörer,
die warten auf solche Ereignisse und werden dann benachrichtigt,
wenn etwas passiert ist,
wenn der Benutzer etwas aufgerufen hat und dann kann man diese Vereignisse verarbeiten,
geeignete Reaktionen erzeugen.
Damit verhindern wir genau das, wie wir es beim Beobachtermuster
schon erklärt worden war, wir benutzt verhindern die zyklische Benutzbeziehung.
Und wir verhindern, dass die sich direkt kennen müssen,
sondern man kann sich da einschreiben. Ja, also der Button,
der muss nicht die Applikationen kennen, sondern es reicht,
wenn der Applikationen den Button kennt und dann sendet der Button eine Benachrichtigung.
Ich bin gedrückt worden über das Betriebssystem. Also das ist
der Mechanismus, wenn Sie das nochmal nachlesen wollten,
würde ich Ihnen empfehlen, einfach mal zur letzten Vorlesung zurückzuschauen.
Beobachtermuster, wie funktioniert das genau mit dem Publish Subscribe?
Wir möchten jetzt erklären, wie wir mit Lizenon arbeiten
So, diese Listener, die sind dazu da,
dass wir eine Schnittstelle bieten, wo der Anwendungsgut unserer Anwendung aufgerufen werden kann.
Und das sind die Listener Interfaces. Interfaces, sie erinnern sich,
das waren sowas ähnliches wie abstrakte Klassen, aber ohne Methoden Rümpfe.
Das heißt, es war nur die Schnittstelle und eine Klasse,
die so ein Interface implementiert. Da hat der Programmierer
die Aufgabe, alle Methoden, die hier abstrakt sind.
Wir sehen das daran, hier Interface, performt und da gibt es
hinten nicht geschweifte Klammer aufgeschweifte Klammer zu, der Buddy fehlt.
Und das muss der Programmierer dann implementieren. Und deswegen hast
du diese Beziehung Implements. Also Action listener ist ein Beispiel
für so ein Lisner, der auf ein Event agiert,
reagiert und dann mit der Methode Action performt, das verfüllt vollzieht.
Und diese Klasse, die die Anwendungskurt-Klasse, Anwendungsklasse implementiert,
dieses Interface und in der Methode von Action-Performen,
die wir gerade gesehen haben, da steckt dann das,
was wirklich als Reaktion passiert.
Und ja, wie wird das aufgerufen?
Das wird so aufgerufen, dass das mit Publish und Subscribe,
also mit Subscribe in dem Fall, angemeldet wird.
Die implementierende Klasse meldet das bei der Kui-Komponente an.
Wenn dann so ein Ereignis passiert, das kann Buttonklick sein,
das kann Wischen sein, je nach Ereignis, ja,
er wird ein Event erzeugt.
Ja, wir haben diese Events schon kennengelernt,
als wir über Fehler gesprochen haben.
Das ist ein bisschen ein ähnliches Konzept.
Es gibt jeweils ein Ereignis vom Typ und sowieso.
Ja, also das ist ein Exemplar einer Klasse
Und hier ein Exemplar dieser Eventklasse. Und das wird alles,
sondern übergeben, die sich angemeldet haben.
Und alle machen dann jeweils Action performt. Und damit wird
eine Reaktion erzeugt. Diese Klassenstruktur sieht so aus,
dass wir also dieses Interface haben, Action listener.
Und der Beispiel ist nur, den wir dann brauchen, der implementiert dieses Interface.
Damit hat er Action performt. Und gleichzeitig ist er eine Unterklasse,
oder es hat er, nein, er hat,
nein, falsch, nicht Unterklasse, bitte vergessen Sie es.
Also, er ist ein Teil von J. Frame,
wo er zugeordnet ist und dafür registriert ist und die Anwendung selber benutzt,
dann diesen Listener, um Aktionen zu starten und das Action-Event ist das Element,
was hier adressiert wird, was ja verwendet wird.
Schauen wir uns das im Ablauf an und was wir uns
jetzt hier anschauen, ist ein UML-Kommunikationsdiagramm. Dieses Kommunikationsdiagramm,
ich sage erst mal was zur Diagrammform, sieht so aus,
dass wir ja Kästen haben für Objekte, bittet es sind Exemplare,
kennen das darin, dass so ein Doppelpunkt davor ist.
Eigentlich ist das ja so in Java, dass wir,
oder überhaupt in vielen objektorientierten Notationen, dass wir hier den Objektnamen haben,
Exemplarnamen und dann den Klassennamen.
Und wenn davor nichts steht vor dem Doppelpunkt, dann wissen wir,
okay, hier ist nur der Klassenname von Rille von der Bedeutung,
aber es geht eigentlich um ein Objekt, ein Exemplar.
Hier das Gleiche nochmal und hier das Gleiche nochmal.
Also die Kästen stehen jeweils für Exemplare, ist ganz klar,
warum zur Laufzeit reden wir von Exemplaren.
Da spielt die Klasse nur die Rolle des Bauschemas. So,
der Benutzer, ach so, das wollte ich noch sagen,
hier die Kommunikationsdiagramm ist, die Pfeile stellen die Reihenfolge und die Weitergabe von sequenzieller Verarbeitung dar.
Also und dann gibt es noch so Ziffern, eins,
zwei, sehen wir drei, sehen wir gleich.
Auch noch, also die Ziffern geben die Reihenfolge an.
Zuerst passiert irgendwie der Benutzer, der ist jetzt hier links
nicht ihr Bild, der klickt auf einen Button.
Ja, und dann wird dieser Button ein neues Exemplar vom
Typ Action-Event erzeugen und dieses Action-Event ist dann hier,
das ist die nachfolgende Aktion
Gleichzeitig, oder danach, nach dem Erzeugen,
wird dieses Exemplar, Eventexemplar übergeben, mit Action performt an
den Listener und der Listener führt damit etwas aus.
Und wir erreichen, und damit, je nach Aktion,
was wir hier brauchen, haben wir unterschiedliche Handlungen.
Das gleiche Event und unterschiedliche Handlungen,
jeder Listener macht irgendwie
etwas anderes
Das ist erst mal so, das Prinzip und was wir jetzt gleich gesehen haben,
diese Notation hier mit dem Pfeilen und den Ziffern dran, das ist ein Kommunikationstiagramm.
Es zeigt uns, so ähnlich wie das Sequenzdiagramm,
die Reihenfolge ist ein dynamisches Diagramm der OML.
Wir machen nicht so sehr viel damit in der nachfolgenden Vorlesung Softwaretechnik,
die Sie im nächsten Jahr besuchen könnten,
können Sie da gerne sich da noch weiter informieren,
beziehungsweise Java ist immer ein UML-Buch,
ist sehr zu empfehlen für Informatiker,
also man sollte ein UML-Buch haben und immer mal nachschauen,
schauen Sie mal nach,
was das Kommunikationsdiagramm
noch so alles kann
Doch wir wollen weitermachen, wie geht das mit dem Events los?
Also wir haben gesehen, die Events werden an den Elizener übergeben,
ja, und jetzt möchte ich kurz erwähnen,
dass es hier eine gute Chance gibt, das funktional,
mit dem funktionalen Paartik mal zu programmieren, zu implementieren.
Und zwar gibt es dazu die Lamtas,
das Konzept der Lamtas in Abiava 8,
dass es ermöglicht, eine Funktion direkt zu übergeben.
Nur ein paar Worte dazu,
wir haben die letzte Vorlesung in dieser Reihe,
geht es ums funktionale Programmier, Quaratigma,
da werden wir genau an das angriffen,
was ich heute sage
Also was sind diese Lambdas? Es sind funktionale Interfaces.
Interfaces, die eine Operation aufrufen, eine Operation übergeben.
Und die dienen häufig nur der Übergabe einer Methode.
Also sie geben nicht Parameter über, so ein übergeben Verhalten.
Ja, es sind keine Zustandsfelder oder sowas, sondern sie übergeben eine Methode.
Und das ist bei Lambdas erlaubt, dass man nur eine Methode übergibt.
Die Syntax ist mit so einem Pfeil, also ich habe den Parameter-Pfeil Expression Body.
Ja, man darf die Typ der Generation sogar weglassen.
Das besteht so ein bisschen im Stil der funktionalen Programmiersprachen.
Die Klammern dürfen fehlen, dass man direkt zu einer Notation hat,
mit so einem Pfeil hier, ja,
geschweifte Klammern dürfen sogar fehlen und das Return da fehlen.
Nun kann man darüber diskutieren, ob das sinnvoll ist,
so viele Sprachmerkmale dann wegzulassen,
sieht es ja gar nicht mehr aus wie Java,
aber die Entwickler haben sich dann entschieden,
da sich ein bisschen weit zu bewegen in Richtung der Sachen,
die üblich sind für funktionale Programmiersprachen.
Ich möchte kurz das darstellen, wie ich einem arathmetischer Operation als Parameter übergebe,
in dem Fall Subtraktion, zunächst definiere ich erstmal,
ja, ich erzeuge ein Konstrukt-Subtraktion, in dem ich sage,
die beiden Parameter werden voneinander subtrahiert.
Und dann rufe ich das auf, dieses ob mit mittels Operate.
Und dann sehen Sie hier in Klammern,
kommt als dritter Parameter, als erster Parameter kommt A,
als zweiter Parameter kommt das, was B wird.
Und als dritter Parameter kommt dieser Funktionsname, der hier deklariert worden ist.
Und das war also diese Deklaration. Hier wird Substraction übergeben
und ich könnte genauso gut eine Wurzel ziehen, multiplizieren, addieren.
Und damit kann ich je nach Funktion je nach benötigter Funktion
etwas anderes machen. Und das ist genau das,
was wir hier im vorgehenden Bild ja auch brauchen.
Wir wollen hier je nach Aktion von dem Listener etwas anderes machen lassen.
Wir können das übergeben. Und das könnte man hier eben
an der dritten Stelle hier übergeben, da werden diese Landars dafür geeignet.
Wie sieht das in Beispielen aus? Wir würden diesen Actionlistener
so implementieren. Ja, das war erstmal klar, das Interface,
das hat man schon gesehen, dass da Action-Perform steht ohne Body.
Das ist einfach nur das Interface. Und wenn wir das aber jetzt implementieren,
sieht das so aus, dass der zum Beispiel,
wir hier etwas haben,
Event, dann dieser Operator und dann sehen wir,
der Zähler zählt weiter und dann irgendwie eine Anzeige in einem Label.
Das ist genau das, was wir vorher mal hatten.
Ich drücke und dann zählt es hoch. Und das kann ich dann übergeben,
at action listener, das kann ich direkt übergeben als übergebene Funktion,
als das, was in Zukunft gemacht wird.
Und da bin ich ganz flexibel, auch mal was anderes zu übergeben. Je nach Zustand,
je nach Fenster, je nach Listener oder was auch immer,
ja, benötigt wird nur der Name für der Parameter, Ja,
das wäre in dem Fall Aid Actionisner und die Implementation dieser Methode,
die wir hier unten in den zwei Zeilen stehen haben.
Soweit schon mal dazu als Vorblick, das wird in der letzten Vorlesung, wenn wir das funktionale Paradigma erläutern. So,
und das, was wir jetzt erklärt haben,
das ist Gegenstand der Frage 5,
ich springe mal zurück zur Folie 2, wo die Fragen sind,
Moment, jetzt geht es gleich dahin, ja,
also Frage 5, worin zeigen sich die Vorteile des funktionalen Programmierparadigmas,
das ist Das ist hier,
dass wir das nur die Methode übergeben können und damit Funktionalität übergeben können und hier jedes Mal eine andere,
je nach Event, eine andere Funktion aufrufen können,
indem wir hier etwas anderes übergeben.
Also hier bei dieser Übergabe. Das wäre hier die Möglichkeit.
So, wir machen weiter. Wir waren schon bei Folie
26 angekommen. Und jetzt möchte ich Ihnen,
nachdem wir kurz diesen Erläuterung mit Lamdas gemacht haben,
noch sagen, was wir noch so für wichtige Listener haben
Also, wir haben zum Beispiel den Radio-Button. Radio-Button ist also eine 1AUS-N-Auswahl.
Ich kann eine Auswahl treffen, genau eine aus mehreren.
Das ist noch so, das heißt Radio-Button,
weil da das gute alte Röhrenradio hatte früher so einen Wahlschalter, entweder sie haben UKW oder Mittelwelle oder Langwelle.
Vielleicht hat irgendein Nostalgie-Fan so ein Radio noch stehen. Also, ich konnte immer genau einen Knopf drücken. Aus dieser Zeit stammt diese Bezeichnung Radio-Button. Ja,
Jay List ist also eine Liste, da gibt es auch,
da kann ich aus einer Liste auswählen,
also hier kann ich einen Item auswählen, hier kann ich aus einer Liste auswählen,
aus der Combo-Box, das war diese Box zum Aufklappen,
ich springe vielleicht einfach mal hin, das waren,
das müsste auf Fully 9 gewesen sein, nein,
war es doch 8, genau, hier ist die Combo-Box,
ja, also ich kann hier auswählen,
zum Beispiel jetzt am Montag ausgewählt oder ich könnte den Freitag auswählen,
wenn das wieder zugeklappt ist, ist es nur dieses eine Element,
was sichtbar sind, Sie kennen das auf jeden Fall,
dieses Ding heißt Combo-Box.
So, nein, wir waren bei 29. Genau
Ja, genau, die Combo-Box hatte ich erklärt und jetzt
noch für das Textfeld gibt es auch noch so ein Action-Disner,
wo ich was bearbeiten kann.
So, für diese Ereignisse gibt es unterschiedliche Typen,
unterschiedliche Eventklassen, die jeweils dieser Exemplare dann liefern.
Die tragen immer die Informationen über das, was ich brauche,
ganz klar so ein Event aus einer Liste,
braucht es anders als nur der Fakt, ja, ich bin ausgewählt worden.
Zum Beispiel liefern die die Informationen jetzt sowas, woher stand das Event,
wo das ausgelöst Get ID gibt es noch mal als Konstante,
den Event-Typ.
Und damit auch und häufig auch eine Methode Consume,
damit das Event nicht mehr weitergegeben wird.
Das wurde dann schon verarbeitet und weitere Fenster kriegen das dann nicht mehr.
Die Events werden in der schon erwähnten Weise von den Lissernon
verarbeitet, die angemeldet sind.
Und so ein Lissner-Interface hat mit diesem Action-Performt dann immer
die Antwortmethoden,
dass man reagieren kann
So, hier noch in der Tabelle, aber das ist nicht abschließend,
es gibt noch weitere, also für Fokus-Event gibt es den Fokus-Listener.
Ja, Fokus ist, also welches Fenster ist gerade im Vordergrund,
wo ich die Maus bearbeitet, im Vordergrund ganz dargestellt.
Dann haben wir noch, wenn irgendwo ein Item sich geändert hat,
Get Item, Items Electric, wenn etwas gewinnt,
da gibt es diesen Methode dafür,
State Changed für Text, Text Listener,
da können wir verschiedene Sachen mit dem Text machen.
Und da wird es einfach nur, wenn wir Enter drücken
oder okay drücken, ist das Ding übernommen. Ich glaube,
bei Inter hier in dem Fall für das Component-Event,
da gibt es vor allen Dingen, dass sich die Komponente verschieben kann,
den Hintergrund legen kann und so weiter.
Das sind also ein Ausschnitt von weiteren Events, die man brauchen kann.
So, und hier noch wieder mal eine Sache für Weiterführende.
Sie kennen das Symbol mit dem Keks schon. Ja,
also es gibt hier Nebenläufigkeit. Fretz werden hier verwendet,
damit parallel alles abgearbeitet wird,
auch wenn wir
mehrere Sachen anklicken
Gehen wir aber nicht weiter darauf ein, nur für diejenigen,
die sich interessieren, was freit sind,
wie ist Reiz hier dabei, verwendet werden, soweit.
Und wir schließen mit einer kurzen Zusammenfassung diesen Abschnitt,
ja,
wir haben diesen Event- und Event-Lisener-Mechanismus,
jeder Methode hat so eine eigene Methode für jede Art von Ereignissen mit Ed
und dann der Event-Lisener und die kann über Publish Subscribe eben angemeldet werden bei der QI-Komponente,
wo das Event auftreten kann und alle angemeldeten
listener Objekte werden benachrichtigt
Das noch stören, ob dann wirklich nur eins bearbeitet oder alle.
Und mit diesem Eventobjekt werden auch Informationen über den Ereignistyp geliefert.
Natürlich auch über den Urheber und so weiter,
aber vor allen Dingen auch über den Ereignistyp.
Soweit in diesem Abschnitt und weiter geht es dann mit
dem Layout-Manager