Ja, hi. Weiter geht's mit dem Beobachtermuster. Dazu
gucken wir uns die Klasse Start-up nochmal ein bisschen näher an.
Wir haben hier einen Bestellservice, der ja dafür da ist,
Bestellungen aufzunehmen. Wir haben einen Bestellauflisterwerkzeug, das dazu dient,
diese Bestellungen dann auf der Konsole auszugeben.
Und jedes Mal, wenn der Bestellservice eine Bestellung hinzugefügt hat,
soll diese Bestellung dann eigentlich auf der Konsole ausgegeben werden.
Wir simulieren hier eine Bestellung, die wir hier an der Stelle hinzufügen.
Wenn wir allerdings auf Start-up Run is Java Application ausführen,
sieht man das ziemlich intensiv nichts passiert.
Also müssen wir uns die beiden beteiligten Klassen auch nochmal näher ansehen.
Das sind hier Bestellservice und Bestellauflister-Werkzeug. Bestellauflister-Werkzeug bekommt hier ein Konstruktor,
ein Bestellservice übergeben und holt sich von dem Bestellservice hier sämtliche
Bestellungen und gibt sie auf der Konsole aus.
Und hier im Bestellservice werden einfach die Bestellungen hinzugefügt und eigentlich soll an der Stelle,
wenn eine Bestellung hinzugefügt wurde, Diese vom Bestellauflister dann auf der Konsole ausgegeben werden.
Was man an der Stelle also machen könnte, wäre eine Exemplarvariable deklarieren.
Von typisch Stell. Auflister. Werkzeug, die nennen wir
. Auflister. Und die wird auch im Konstruktor mezialisiert mit
einem neuen Exemplar der Klasse
Bestellauflisterwerkzeug, der übergeben wir, auch wenn es im
ersten Moment ein bisschen eklig klingt, uns.
Und dann könnten wir hier unten auf Auflister.
Mit Punktoperator, Zeigebestellung an, aufrufen. Das würde technisch
auch funktionieren. Wenn wir jetzt hier Start-up,
Run is Java Application laufen lassen,
dann sehen wir hier unten,
dass die Bestellungen auch ausgegeben wurden
Das hat nur das folgende Problem. Wir haben hier sowieso schon im Bestellauflister-Werkzeug,
weil wir ja ein Bestellservice übergeben bekommen haben und den
hier der Exemplar-Variablen zuweisen, eine Exemplar-Variable vom Typ Bestellservice.
Im Bestellservice haben wir jetzt auch ein Exemplar variable, vom Typ Bestellaufliste.
Das heißt, wir haben eine statische, zyklische Abhängigkeit.
Statische, zyklische Abhängigkeiten sind böse. Die haben ein großes Problempotenzial
. Zum einen bei der Testbarkeit, wir können nicht ein
Die Klasse Bestellservice testen, ohne auch ein Exemplar der Klasse
Bestellofflister, Werkzeug zu erzeugen und umgekehrt.
Es hat aber unter Umständen auch große Wartbarkeitsprobleme,
weil Änderungen an der Klasse Bestellservice könnten sich auch sehr eng
auf Bestellofflister-Werkzeug auswirken und umgekehrt.
Das heißt also, das kann sehr große Probleme bei der
Testbarkeit und bei der Wartbarkeit mit sich bringen.
Deswegen statische, zyklische Abhängigkeiten sind böse.
Also machen wir mit ganz viel Steuer und Z
den ganzen Kram wieder weg
Und hier auch. Und hier auch. Es gibt eine Möglichkeit,
solche statischen, zyklischen Abhängigkeiten aufzulösen, diese Möglichkeit ist,
das Beobachtermuster. Das Beobachtermuster ist ein Entwurfsmuster,
ein Entwurfsmuster sind, da haben sich Leute,
die ganz schlau sind für immer wiederkehrende Probleme in
der Softwareentwicklung,
Lösungen ausgedacht
Und das Beobachtermuster ist eben eine solche musterhafte Lösung,
die auf den eigenen Code angewendet wird, für statische zyklische Abhängigkeiten.
Das heißt, um diese statischen zyklischen Abhängigkeiten zu vermeiden,
außer unseren beiden Klassen haben wir hier das Interface, das beteiligt ist.
Das heißt, Beobachter und hat als einzige Operation, reagiere auf Änderung.
Und dann haben wir noch eine abstrakte Klasse, beobachtbar.
Die hat ein Set, in das die Beobachter hinzugefügt werden,
und zwar mit der Methode, registriere Beobachter.
Und sie hat eine Methode, informiere über Änderung.
Unser Bestell-Off-Lister-Werkzeug Äh, implementiert hier, reagiere auf Änderung.
Und unser Bestellservice wird dann dieses Reagierer auf Änderung
immer dann auslösen, wenn eine Bestellung hinzugefügt wurde.
Also, implementieren wir das Ganze jetzt mal als allererstes
das Interface,
das heißt Beobachter
Und hat als einziger Operation, reagiere auf Änderung.
Und als nächstes dann eine Klasse, die ist abstrakt,
heißt beobachtbar. Wir werden zwar keine einzige abstrakte Methode
da drin haben, aber wir wollen kein Exemplar davon
Erzeugen können. Und deswegen machen wir sie abstrakt.
Da haben wir ein Set, in das Beobachter dürfen.
Und das nennen wir mal Beobachter.
Set müssen wir
offensichtlich importieren
Und hier werden wir das dann im Konstrukt erzeugen.
Echt, you. Hash-Set. Dann haben wir
die Methode. Fügebeobachter hinzu. Die nimmt einen Beobachter entgegen
Den nennen wir Beobachter. Und die Methode tut nichts anderes
als mit Ed. Den Beobachtern hinzuzufügen zu dem Set.
Dann haben wir noch eine Methode,
informiere über Änderung
Und die ist dafür da, auf jedem Beobachter in
diesem Set dessen Methode, reagiere auf Änderung.
Aufzurufen, das machen wir also mit einer erweiterten oder auch schöneren Vorschneider.
Da wird uns alles schon richtig angeboten und hier unten ist,
dann beobachte, Punkt,
reagiere auf Änderung
So, jetzt haben wir Beobachter und beobachtbar geschrieben.
Jetzt müssen wir noch unseren Bestellservice und Bestellauflister-Werkzeug damit verknüpfen.
Gucken uns nochmal das UML an. Bestell auf Lister-Werkzeug soll
das Interface-Beobachter implementieren. Dann sorgen wir mal dafür. Bestell auf Lister-Werkzeug.
Im Moment Obachter. Das wird rot unterkringelt und ich hoffe,
Das liegt nur an einem Import, das tut es.
Hier wird jetzt gesagt, haha, du implementierst es gar nicht,
weil die Operation eben nicht als Methode implementiert ist,
Steuerung 1, at unimplemented methods.
Hier haben wir gleich unser Reagierer auf Änderung und die Reaktion auf die Änderung
soll eben darin bestehen, dass einfach Zeigebestellungen aufgerufen wird, Zeigebestellungen an.
Das ist unsere Reaktion auf die Änderung und jetzt muss noch unser Bestellservice
Von der Methode beobachtbar erben. Und auch hier fehlt uns ein Import.
Und damit hat unser Bestellservice ja das Set mit den Beobachtern.
Und dem können wir dann, dem kann sich dann das Bestellauflister-Werkzeug hinzufügen.
Das heißt also, wir haben hier das Bestellauflister-Werkzeug,
da haben wir ja unseren Bestellservice. Da rufen wir dann
auf unserem Bestellservice. Die Methode füge Beobachter hinzu.
Und das machen wir mit This, weil wir uns selber hinzufügen wollen. Und dann müssen wir nur noch dafür sorgen,
dass hier in Bestellservice die Methode informiere,
über Änderung aufgerufen wird, die ja nichts anderes bedeutet,
dass auf allen Beobachtern, die in unserem Set drin sind,
dass wir jetzt hier nicht sehen,
weil die es ja von Beobachten beobachtbar geerbt haben,
Da wird dann Informiere über Änderung, sagt nichts anderes als,
wir rufen auf jeden unserer Beobachter, dessen Methode reagiere auf Änderung auf.
Und das ist ja gerade diese Methode,
reagiere auf Änderung, die hier dann zeige Bestellungen auslöst.
Und eigentlich sollte es das dann auch schon gewesen sein.
Run is Java Application und wir sehen,
hier werden sämtliche Bestellungen aufgelistet
Das heißt also, wir haben ohne eine statische zyklische Abhängigkeit es geschafft,
dass eben das, was hier passieren soll, auch tatsächlich passiert.
Ich gehe das nochmal ein bisschen langsamer mit euch durch.
Also, wir haben hier ein Interface mit der einzigen Operation
, reagiere auf Änderung.
Dieses Interface wird von Bestellofflister-Werkzeug implementiert. Das heißt also,
das Bestellauf-Lister-Werkzeug will
den Bestellservice beobachten
Der Bestellservice ist dadurch beobachtbar, dass er von der Klasse beobachtbar erbt. Der Bestellservice hat,
also die hat also im Prinzip in sich das geerbte Set mit den ganzen Beobachtern,
hat eine Methode auch durch Erben,
die einen Beobachter hinzufügen kann und hat eine Methode, informiere über Änderung.
Wenn wir uns das hier in beobachtbar nochmal angucken, informiere über Änderung,
sagt nichts anderes als geht das Set durch Ja, nimm jeden Beobachter,
der in dem Set Beobachter drin ist und ruf auf ihm,
dessen Methode reagiere auf Änderung auf.
Und hier haben wir den Bestellservice,
Bestellservice ist ja beobachtbar, hat dieses Set,
das Bestellauf-Lister-Werkzeug fügt sich selber,
diesem Set hinzu
Damit sagt es im Prinzip, hey, ich möchte den Bestellservice beobachten.
Und das bedeutet wieder, dass jedes Mal,
wenn im Bestellservice informiere, über Änderung aufgerufen wird,
auf Bestellauflisterwerkzeug, dessen Methode reagiere auf Änderung aufgerufen wird.
Und das bedeutet, dass hier einfach die Methode zeige,
Bestellung an aufgerufen wird.
Ja, das war's einigermaßen kurz tatsächlich schon von mir
zum Beobachtermuster
Ich kann noch dazu sagen, dass sowas wie Beobachtermuster
relativ gern auch in Klausuren gefragt wird.
Mal abgesehen davon, dass ihr es, ich glaube,
beim nächsten oder übernächsten Übungszettel sowieso in der Übung machen müsst.
Und dann vielleicht noch als kleinen letzten Tipp am Ende.
Ihr werdet irgendwo in den Folien von Professor Riebisch
etwas finden, wo so eine Reihenfolge angegeben ist.
Das ist so ein kleines Diagramm, Werkzeug, Service,
Material,
Das ist so eine Rangfolge, was, worauf zugreifen kann.
Werkzeuge können auf sich selber auf Services, auf Materialien und auch Fachwerte zugreifen.
Services können auf sich selber und auf Materialien und Fachwerte zugreifen.
Materialien können auf sich selber und auch Fachwerte zugreifen.
Fachwerte können nur auf sich selber zugreifen. Ich habe,
glaube ich, noch nicht sehr viele Klausuren gesehen,
wo das nicht drin vorkam.
Also das Ding kennt ihr bis zur Klausur auswendig.
Ja, und ansonsten war es das jetzt von mir und
wir sehen uns
nächste Woche