Wir schauen uns hier an, was eigentlich passiert,
wenn wir diese Struktur verwenden,
also das Event wird übergeben, dieses Action-Event wird übergeben,
Antilizener und die führen das Action performt aus und dann passieren die verschiedenen Aktionen, die wir eigentlich brauchen.
Und jetzt kommen wir dazu, dass wir sagen können,
okay, wie machen wir denn das, diese Aktion übergeben,
wenn es doch jedes Mal eine andere sein soll und dazu gibt es ein nettes nettes Konzept,
nämlich die Lamdas, die möchte ich Ihnen jetzt vorstellen.
Und das ist gleichzeitig etwas, wo wir das funktionale Paradigma anwenden,
was wir in der letzten Vorlesung behandeln werden.
In der letzten Vorlesung schon mal als Ankündigung werden wir über funktionale Programmierung sprechen,
weil das ein weiteres Programmierkonzept ist, was wir unbedingt brauchen,
was ist Gutes zu wissen.
Und hier sehen wir schon mal, greifen wir schon mal darauf hin vor,
wie können wir so ein funktionales Protoparadigma anwenden.
Diese Lamdas. Lamdas gibt es noch nicht so sehr lange in Java,
erst seit Java 8 und das sind am Ende funktionale Interfaces.
Das heißt, ich rufe eine Funktion auf und die Funktion ist also,
dass der Parameter Ich weiß nicht, wir kennen solche Sachen,
wo ich datenübergeheweils Parameter.
Ja, ich mache das Sortieren mit diesem Array oder ich muss das multiplizieren,
mit dieser Zahl oder ich stelle ein String da oder was auch immer.
Und manchmal möchten wir auch mal, haben wir aber diesen
Bedarf, dass wir eine Funktion übergeben wollen.
Und diese Funktionen übergeben, das ist in funktionaler Programmierung gang und gäbe.
Das ist für uns ein bisschen ungewöhnlich,
aber Java erlaubt das mit den Lamdas.
Wir können hier eine Methode als Parameter übergeben,
wo wir sagen, also bitte tue jetzt mal dieses.
Und am nächsten Mal tue bitte jenes
Nicht davon, was für Aktionen wir brauchen.
Dafür lässt sich das bei diesen Listenern sehr gut eingeben.
Also was wir haben, wie sieht die Syntax aus?
Wir haben Parameter, dann so ein Feldsymbol und dann der eigentliche Ausdruck.
Dabei darf ein Typ Deklaration, darf durchaus fehlen.
Wir dürfen die Klammern weglassen, wir dürfen geschweifte Klammern weglassen.
Sogar das Return darf fehlen. Wir sind,
damit sie sehen, wie das aussieht, das hat man gemacht,
um sich an den Stil der funktionalen Programmierung so ein bisschen anzulehnen.
Damit sieht es natürlich ein bisschen anders aus, als das
klassische Jahr war. Deswegen möchten wir Ihnen das gerne vorstellen,
dass sie nicht schockiert sind, weil sie sowas mal sehen,
beziehungsweise dass sie sich das auch selbst mal aneignen können.
Ja, also wir haben hier, wir definieren wie eine Operation aussieht,
zum Beispiel Subtraktion von zwei Parametern, die gibt den Wert Aminus B zurück.
Ja, so und das ist,
wird so aufgerufen, dass wir sagen, okay,
my Object Operate und dann gibt es die beiden Parameter und wir sagen, was passieren soll.
Diese Ausdrucksform hier unten, die es so einen Aufruf gibt,
uns die Möglichkeit, also wir sehen hier im Aufruf,
geben wir erst mit, was gemacht werden muss.
Das ist ganz anders, als wir das sonst in Java haben,
gibt uns aber die mächtige Möglichkeit zu sagen,
bitte tue jetzt jenes um Poetitue jetzt dieses,
abhängig von der Operation, die wir gerade tun wollen.
Wir wollen das verwenden bei den Listeners, ja,
und zwar, wir wissen schon,
das wird von Event Listener alles abgeleitet und der Action Listener,
der hat hier Code, der basiert, wenn eine Aktion auftritt,
nämlich dieses Action performt.
So würde das normalerweise aussehen. Wenn wir es mit Landars machen wollen,
können wir das so machen, dass wir letztlich die Operationen übergeben.
Und das passen wir, passiert so, dass wir nur
den Namen brauchen für den Parameter und die Implementation der Methode.
Das wäre hier die Implementation der Methode. Wir erhöhen
den Zähler und setzen den Text. Das ist das,
was passiert, als wenn so ein Event eintritt.
Das ist hier natürlich bei einfachen Fällen sieht man den Effekt noch nicht so stark.
Wir brauchen das ja vor allen Dingen, wenn man große,
komplexe Anwendung hat, indem man mal das,
mal das,
mal das macht
Okay, soweit zu den Landars und wir gehen weiter, was wir für Lizenor brauchen, wo wir die dann einsetzen können. Wir haben als wichtige Lizenor den Action-Lizenor und den Item Lizenor,
wenn wir Radio-Buttons brauchen, den Action-Lisenor List, Action-Lisenor,
wenn wir Listen brauchen, also hier kann ich Radio-Button,
das war der Knopf, wo einer,
wo ich immer nur einen auswählen kann,
wenn ich in einen drücke, geht der andere wieder aus,
die von Ihnen, die so ein ganz altes Radio haben,
da kommt der Name nämlich, wo ich immer,
wenn ich deinen UKW gedrückt habe,
sprang die Mittelwellentaste wieder raus und wenn ich Langwetter gedrückt habe,
sprang die UKW-Taste wieder raus,
daher kommt der Name Radio-Button,
da brauche ich also bei allen solchen gedrückten Elemente
Eine Liste, muss ich die Liste auswählen,
deswegen habe ich solche Events mit der Combo-Box,
das war das zum Herunterklappen,
da brauche ich auch so ein Action und ein Itemnis noch und beim Textfeld,
den möchte ich bearbeiten mit Klicks, da brauche ich Action-Disner.
Wenn wir diese Events und Listener verwenden,
dann gibt es zu jedem Typ von Ereignissen eine Eventklasse,
wo alle Informationen drinstecken, die wir da brauchen.
Ja, also Beispiele hier,
Get Source liefert etwa Sket ID, liefert etwas oder Konsum,
das können wir, wo wir das Event verbrauchen können,
wo wir
das Event anwenden können
Und die Lissner melden sich dafür an. Sie sind dann dafür zuständig, den Reaktionen zu tun.
Und damit sind in dem Lissner gleichzeitig alle Sachen definiert,
die ich dafür brauche, die ich als Entwickler,
sie wissen ja, ein In-Interface zwingt die Entwickler, alles zu implementieren,
sonst wäre es nicht, sonst bleibt noch was abstrakt.
Weitere Beispiele, wir haben schon ein paar gehabt,
wenn wir irgendwie so ein Event-Typ haben, Fokus-Event,
dann gibt es den Fokus-Lissner und Methoden,
die ich dabei aufwerfen kann oder den Item-Event,
wenn ich irgendwelche Elemente anklinke, zum Beispiel Item State Change,
könnte ich dann machen, Get Item
Item Selectable Item Stage Change. Dann gibt es noch Text,
Component, Event und so weiter. Es gibt noch viele
, viele mehr Events. Am Ende ist es so,
hier spricht mir drin wieder der Spruch,
sowas lernt man nicht in der Hörse, im Hörsaal,
das lernt man dadurch,
dass sie sich das anschauen können.
Und deswegen empfehle ich ihnen auch,
damit wirklich zu arbeiten
Ich möchte noch als weiterführenden Konzept,
Sie sehen den Keks wieder oben, das ist etwas,
was Sie nur darauf hinweisen, dass es das auch noch gibt,
dass man nicht Nebenläufigkeiten hier arbeiten kann,
dass man nicht nur alles in einer Kette von Aufrufen macht,
sondern wo dann zwischendurch Sachen nicht bearbeitet werden sollen,
man versucht, das nebenläufig zu machen und dazu sind Fracks,
Reds geeignet, nebenläufiger Ausführungsstränge, das geht zu weit,
dass wir das in SE2 hier verhandeln, behandeln,
das führt ein bisschen weiter, da muss man noch mehr wissen,
auch bei Verteidigungssystemen landen sie Techniken kennen,
wie sie die Reds dazu programmieren,
dass sie kein Deadlock hinkriegen,
wenn sie
gemeinsame Ressourcen benutzen
Kurze Zusammenfassung, diese Eventlistner, die Events und Eventlisten,
also so ein Mechanismus, der dazu da ist,
den wir deswegen haben, damit wir Unabhängigkeit haben,
damit wir nicht typische Abhängigkeiten bekommen,
die für jede Gui-Komponente gibt es solche Ereignisse und dabei,
die implementiert die und führt die zusammen.
Ja, man meldet sich an und wird das Ereignis ausgeführt,
erhält man ein Nachricht,
das ihr Ereignis wird übergeben und mit diesen Ereignissen und mit dem Informationen,
über ein Ereignistyp, macht dann das Eventobjekt irgendetwas,
also löst dann irgendetwas aus.
Und in Werkzeugen ist das dass die technische Basis, damit wir wirklich Ereignisse verarbeiten können.
Wir hatten die Zweifel in zwei Klassen bestimmt und jetzt wieder diese,
ich hatte damals so gesagt, die mittlere Rolle,
die Mittlerrolle, möchte ich jetzt ein bisschen dadurch genauer erklären,
dass Werkzeugklasse ist das, was auf die Ereignisse reagiert.
Und das macht sie mit genau diesen Lizenon. Und damit
die Reaktion immer angepasst sind, dafür können wir die Landars verwenden.
So, das Werkzeugklasse benutzt die UI-Klasse wiederum und stellt dann
Dinge dar, setzt die Informationen dar und so weiter.
Und da können wir auch unter anderem ein Layout oder
so etwas dazu verwenden
Dazu gab es auch eine Frage, und zwar erläutern sie
die Vorteile des funktionalen Programmierkartigs mit dem Lamda-Konzept.
Das war also das, dass wir direkt eine Funktion,
eine Methode als Parameter übergeben können, um zu sagen,
tue jetzt dieses oder tue jetzt das und das
muss der Programmierer nicht zu der Zeit schon genau wissen,
sondern wir können es als Parameter mitgeben.
Das war hier ein wichtiger, wichtiger Punkt. War das
das, was ich Ihnen sagen wollte dazu? Ja,
und wir sind schon immer mal zu der Frage 7 gekommen,
wie das mit den Werkzeugklassen ist,
die da
eine Rolle spielen