Mein Name ist Guido Gritzan und auf meiner Uhr ist es jetzt 14.15 Uhr,
die da, wenn ich das richtig beobachtet habe,
geht ziemlich konstant 16 Minuten nach.
Also ich werde nach dieser Zeit hoffentlich um halb vier hier aufhören,
sollte ich länger als halb vier auf dieser Uhr sprechen,
machen Sie sich bitte bemerkbar.
Ich will ja auch Ihre Zeit bei dem Wetter
nicht über die Übergebühr beanspruchen
Ich habe heute das Vergnügen, Ihnen ein Thema nahe zu bringen.
Sie sehen den Titel schon da, Entwurfsmuster,
von dem ich mir sicher bin,
dass es sie die nächsten, wie alt sind sie so?
20, 22. Also ist ja auch egal. Jedenfalls die
nächsten 50 Jahre, also ihr Berufsleben, würde sie begleiten.
Da habe ich mir vergleichsweise sicher. Und insofern freue ich mich darauf,
dass jetzt die nächsten anderthalb Stunden hier vor Ihnen ausbreiten zu dürfen,
was Entwurfsmuster, was das um Gottes Willen sein könnte.
Bevor ich das tue, hat mich Christian Späh gebeten,
das da anzukündigen
Er hat mich wissen lassen, Axel Schmolitzki gehört auch dazu.
Das ist unter ihnen Menschen gibt, die sich unterfordert fühlen.
Durch das, was sie in den Übungen zu leisten haben.
Für die, die dann, also nicht irgendwie statt Hobbys
haben wie Bungee-Jumping oder irgendwas Herausforderndes, Körperliches.
Gibt es diese Aktion, das Mini-Projekt Creativity Contest
So, ich weiß darüber ziemlich genau das, was da steht.
Also ich sehe die Großen, die großgeschriebenen Sachen sehe ich auch.
Also das ist etwas, was sie in ihrer Freizeit machen können.
Das soll etwas entwickelt werden, was über die Übungsaufgaben,
über die Themenstellung der Übungsaufgaben hinausgeht.
Sie können sich unterstützen lassen dabei von ihrem SE2-Betreuer, also ihrem Übungsgruppenleiter.
Und es wird am Ende einen Gewinner geben. Ich habe
dann als erstes gefragt, so als ich das gesehen habe,
gibt es Geld für den Gewinner?
Die Frage ist im Raumverhalt
Keine Antwort gekriegt. Also gehen Sie mal davon aus,
dass es kein Geld gibt.
Es gibt halt einen Gewinner-Urkunde-Pokal, irgendwas von der Sorte.
Und so dü-dü-dü-dü-dü-dü-dü-dü, da, neun Postdorf ist derjenige,
bei dem sie sich registrieren lassen können.
Also viel Spaß dabei. Ihre Kreativität im Rahmen von SE2,
freiwillig in ihrer Freizeit, ohne Geld austoben zu können.
So, jetzt zum Thema. Ich wollte Ihnen,
bevor ich mit den eigentlichen Folien anfange,
wollte ich Ihnen was gezeigt haben.
Nein, nicht mein Schreibtisch.
Das da
So, ich hätte Ihnen auch gerne ein Bild meines Thorax,
meiner Lunge gezeigt. Leider ist das Programm,
mit dem man das anzeigen kann, gibt es nur für Windows,
da ich hier keine Windows-Partition drauf habe,
muss es jetzt ein Bild aus dem Handbuch sein.
Was ist das? Studiert jemand von Ihnen Medizin im Nebenfach?
Keiner. Na gut, dann nicht. Also man weiß,
also ich, was ist so ein Herz oder ist ja
auch wurscht
Arzt, vermute ich mal,
wird es erkennen und er wird wahrscheinlich sogar auch noch erkennen,
ob das, also gut ist,
was er da sieht oder ob es nicht mehr lange dauert,
bis es gar nicht mehr schlägt oder sonst irgendwas tut.
Und das ist also in der Medizin,
spielen diese bildgebenden Verfahren, da sitzt du ja Diagnose von,
was weiß ich nicht was, spielen eine große Rolle.
Also angefangen hat es so mit Röntgenaufnahmen und dann heutzutage gibt es ja so eine ganze Palette von Computer-Tomografien,
Kernspin-Tomografien, also alles so Verfahren, die da zu dienen,
einen Blick ins Innere zu werfen,
ohne den Patienten jetzt aufmachen zu müssen und trotzdem eine Handlungsorientierung zu bekommen,
was man denn jetzt noch eigentlich machen soll als nächstes.
Also so ganz unmedizinisch ausgedrückt. Und das ist sehr schön
. Da wollen wir eigentlich auch hin als Informatiker.
Und wenn wir uns so die Welt von innen anschauen,
dann sieht das manchmal so aus. Also so,
dass jetzt kein Bild gebendes Verfahren,
das hier diesem Bild zugrunde liegt,
sondern eine sogenannte Computer-Tomografie, eine Software,
also eine Software-Tomografie und die
funktioniert ungefähr so
Man hat hier also Code, sagen wir,
Java und man hat also eine Architekturbeschreibung für diesen Code,
die ist hier und dann lässt man da ein Stück Software,
nämlich den Software-Tomografen drüber laufen und der stellt fest,
also in wie gut passt die Struktur des Codes mit der Architekturbeschreibung zusammen.
Und dann kommt da so ein Bild bei raus.
Und jetzt sind sie ja, sie sind ja keine Ärzte,
sie sind ja angehende Informatiker, Wirtschaftsinformatiker,
was auch immer sie da jetzt, also im Einzelnen studieren,
jedenfalls Software, das ist das, so was sie beherrschen.
Und jetzt gucken sie da drauf und jetzt erwarte ich eigentlich von ihnen,
dass sie mir sagen können, Das geht nicht mehr lange gut.
Oder alles in Ordnung. Ich habe jetzt dieses Sturesi-Ding nicht dabei. Also ich denke,
also ich gucke da jetzt mal drauf und denke,
also so Struktur kann ich da nicht wirklich drin erkennen, oder?
Und das ist etwas, da ist auch keine drin.
Man könnte jetzt anfangen zu interpretieren, warum ist das da,
warum ist das da oben so zehn Zentimeter größer,
müsste ich sein, warum ist das orange?
Hat das eine Bedeutung? Hat das hier eine Bedeutung,
dass es grün und das ist rot?
Also für die rot-grün-blinden unter ihnen,
da ist noch
ein Unterschied
Und wieso sind die hier nicht mit dem Rest verbunden,
die da oben, aber so ganz viel miteinander verbunden?
Der Stand der Kunst in der Informatik, was also
bildgebende Verfahren anbetrifft, ist eigentlich eher mit Höhenforschung vergleichbar.
Sie kriegen also so eine Höhlenmalerei wie das da.
Und dann können Sie sich überlegen, was wollte der Künstler uns damit sagen?
Und das ist ein Zustand, der ist eigentlich überraschend,
weil so wir uns doch so, wir denken doch immer,
dass wir so an der vordersten Front der Entwicklung,
also mindestens der IT-Entwicklung,
Gegenstand dieser Vorlesung ist es,
also ihnen mit Entwurfsmustern ein Mittel an die Hand zu geben oder sie jetzt zunächst mal damit bekannt zu machen,
wie können wir verhindern,
also wie können wir Softwareentwickler verhindern, dass Code entsteht,
der so eine Struktur hat, weil das da ist,
also das ist so gut wie unwartbar,
wenn man sowas so vor sich sieht,
also wenn man mal in ein Unternehmen geht und man analysiert dort deren Software und man kriegt sowas raus,
Da muss man dann schon, also viel,
es ist wie mit so einem Patienten, der nach,
sagen wir, 30 Jahren rauchen und trinken und was weiß ich,
was für Drogen, muss man als Arzt wahrscheinlich auch sagen,
das wird einem Marathon laufen,
also das lassen wir mal lieber den Plan,
wir arbeiten jetzt erstmal so an was Kleinerem.
Okay, so von hier bis zur Theke,
das machen wir jetzt nicht mehr,
das machen wir jetzt wieder zu Fuß, oder?
Das schaffen wir. Also sowas wollen wir verhindern,
dazu dienen Entwurfsmuster,
was ist das
Also, das haben sie gesehen. Und wir nähern uns diesem Thema jetzt,
also ich, wenn ich jetzt wir sage, meine ich,
also wir nähern uns jetzt diesem Thema mal schrittweise.
Schauen Sie mal da drauf. Das ist so die Art von Oberflächen,
die Sie, also entweder jetzt schon bauen können oder demnächst
bauen können, also so eine Art von interaktiver Oberfläche.
Und das, da ist ein sehendes Datum, Montag,
13. Mai 1996, da ist wahrscheinlich der Screenshot für dieses Überweisungswerkzeug entstanden.
Und das Ding ist also, ist also historisch,
ist halt sozusagen historischen, nicht hysterischen,
historischen Wert
Die Abkürzung da, die kennen möglicherweise nur noch die wenigsten von ihnen,
das steht für deutsche Mark. Das war also die Währung,
bevor es zu dem Euro gekommen ist, manche behaupten,
vielleicht wird die Folie mal wieder aktuell,
das schauen wir mal, das ist so eine andere Geschichte.
Also was hier passieren soll, ist, dass 1500 Deutsche Mark
vom Konto des Auftraggebers an das Konto des Empfängers überwiesen werden.
Soweit, so gut. Also jetzt mal abgesehen von dem Währungswitz
ist da noch ein anderer Witz drauf auf dieser Folie,
der besteht darin, Der Überweisende sieht den Kontostand desjenigen,
an denen er etwas überwiesen hat oder überweisen wird.
Weiß man nicht so genau, wenn man da auf die Folie draufschaut.
Was datenschutzrechtlich kritisch ist. Das ist, sagen wir mal,
das technisch ist es möglich, das zu machen,
aber wie das immer so ist, also das,
was technisch möglich ist, ist nicht unbedingt das,
was also gesellschaftlich oder juristisch haltbar ist
Aber insofern ein gutes Beispiel dafür, dass also Softwareentwickler,
die entwickeln dann halt so für sich und denken,
das ist eine gute Idee und dann kommen halt die Leute,
die sagen, das geht so nicht aus fachlichen, organisatorischen, juristischen Gründen,
können wir diese Lösung so schön, wie sie ist,
können wir sie leider nicht im betrieblichen Alltag einsetzen.
So, das haben sie jetzt aber verstanden,
man kann da also die üblichen Sachen eingeben und dann kriegt man,
drückt man auf dieses Knöpfchen da überweisen und zack,
ist auf dem Konto des Auftraggebers der Betrag, der hier steht,
muss man im Haus, hier, der Betrag,
der hier steht, abgezogen und hoffentlich ist er da drauf, plus Gebühren und was da sonst noch alles dazugehört.
So, jetzt will ich Ihnen zeigen, wie konstruieren wir
Und wir konstruieren sowas, nämlich so ein Überweiser,
zunächst mal dadurch, dass wir diese Klasse da implementieren.
Was steckt da so im Einzelnen drin? Zunächst mal machen wir
eine Annahme darüber, nee, sollte es umgekehrt formulieren,
wir machen keine Annahme darüber, wie dieser Überweiser eigentlich interaktiv realisiert wird.
Wir haben zwar so eine Vorstellung davon,
also wie der an der Oberfläche aussieht,
aber eigentlich wollen wir uns erst mal nicht eigentlich,
sondern wir beschäftigen uns erst mal damit,
wie das ganze Ding funktional aussehen soll.
Funktional bedeutet, wir überlegen uns diese klasse Überweiser und
da gibt es so verschiedene Arten von Operationen,
die das Ding an seiner öffentlichen Schnittstelle hat.
Also so mal beispielhaft hier,
man setzt also den Auftraggeber und der Auftraggeber ist,
da ist dadurch charakterisiert, dass es eine Kontonummer und eine Bankleitzahl gibt.
Mehr brauchen wir von dem nicht zu wissen. Nur das
Gleiche, ich bin ein Empfänger. Es gibt eine Operation,
da wird wirklich was getan, nämlich da wird dieser Betrag jetzt Parameter übergeben wird.
Der wird auch tatsächlich überwiesen. So,
dann gibt es noch hier Funktionen, mit denen man also überprüfen kann,
also was ist denn jetzt eigentlich so das Saldo,
also der Kontostand auf Deutsch, das Saldo auf dem Empfängerkonto,
was ist der Kontostand des Auftraggeberkontos?
Also das sind Funktionen, während die Prozeduren die sie hier sehen,
die verändern den Zustand eines Objektes der Klasseüberweise bei den Funktionen.
Hier wird ein Wert geliefert und das lesen sie ja auch
schon wie Zeitungen mit Großbuchstabigen, mit großen Buchstaben.
Also hier wird ein Wert von einer Funktion geliefert.
Der, was man zusätzlich noch sagen kann, ist,
dass diese Funktion den Zustand des Objektes nicht verändert.
Und dann gibt es noch ein paar Bulsche Operationen,
die sehen Sie hier
Das sind sogenannte Prädikate. Diese Prädikate machen eine Aussage über den Zustand des Objektes.
Also ob es sich um ein gültiges Konto handelt,
gibt es die Kontonummer und fragen dieser Art,
also wenn das mit Ja beantwortet ist,
dann kann man sicher gehen, dass also sowohl Empfänger,
dass das Konto, das man hier identifiziert hat,
dass das eben ein gültiges Konto ist, sonst nicht.
So, das ist die funktionale Schnittstelle des Überweisers und das
ist jetzt so gleich, nicht,
dass ich es ihnen jetzt hier noch mehrfach Tipps für ihr restliches Berufsleben geben möchte,
aber so wie das Ding da steht,
kann man
das implementieren
Und man könnte jetzt zum Beispiel so eine Kommandozeilenartige Schnittstelle da
oben drüber setzen und dieses Klasse, also interaktiv so bedienen.
Also das ist zwar nicht so bequem, gemütlich,
wie in so einer grafischen Oberfläche. Aber was wir erreichen wollen,
also da kämen wir dann schon einen Schritt näher,
nämlich eine Schnittstelle für den Überweiser, so implementieren,
dass er keine Annahmen darüber macht, in welchem Kontext er eigentlich eingesetzt wird.
Also ist es ein interaktiver Kontext oder wird diese Klasse meinetwegen,
ach, in einem Dauerauftragssystem verwendet, da wird ja auch ständig was überwiesen,
denn was ist ein Dauerauftrag anderes als eine regelmäßig stattfindende Überweisung.
Also insofern Diese Implementation ist da durchaus hilfreich. So,
jetzt kommen wir da hier nochmal kurz zusammengefasst,
also was die, was für,
ob Arten von Operationen in so einer Klasse unterscheidbar sind oder welche wir unterscheiden wollen,
die verändernden Operationen, sprich also Prozeduren, die sondierenden fachlichen Operationen,
das sind also, die verändern den Zustand des Objektes nicht,
wenn man sie aufruft, es sind halt Funktionen und die sondierenden bullschen Operationen,
die kann man auch Prädikate nennen, also Prädikat deswegen,
weil sie einen Bullschenwert zurückliefern.
So, diese Arten von Operationen unterscheiden wir und das kann
man eigentlich immer an, also Klassen dieser Art sehen.
Also wenn ich etwas verändert habe, dann möchte ich sehen,
ob das gelungen ist. Dafür brauche ich also Funktionen. Also so dieses,
so ein Wechselspiel zwischen verändernden und sondierenden Operationen und ob ich etwas tun darf,
das kriege ich in der Regel mit,
also indem ich ein Prädikat implementiere, also eine Bullshit, eine Butsche Operation.
Was wir ja jetzt wollen, so das Bild von dem
Überweiser sehen Sie vor sich
Wir wollen den interaktiv benutzen. Das heißt, wir wollen eine grafische Benutzungsoberfläche schreiben.
Und dazu stehen jetzt hier zwei Aufgaben, also mal abgesehen davon,
dass wir diese Klasse Überweiser implementieren müssen und das,
was da unten noch so möglicherweise dranhängt.
Wir müssen also eine interaktive Oberfläche, also eine Oberfläche implementieren,
die diese Art von Interaktion, wie wir sie im Auge haben, ermöglicht.
Und dazu steht hier so schön,
es sitzt in Zeiten, also des Hochwassers,
also es ist vielleicht eine nicht so tolle Formulierung,
aber wie dem also metaphorisch,
wir nehmen einen Strom von Ereignissen entgegen
Also das, was da so an der Oberfläche passiert,
das sind Ereignisse, die ausgelöst werden von einem Benutzer.
Also wenn du da mit der Maus so über die Oberfläche fährt, wollen wir das mitbekommen.
Und wenn er dann so um den Knopf kreist,
also wollen wir ihn vielleicht mal fragen,
also willst du jetzt vielleicht mal langsam drücken,
nachdem du jetzt hier 20.000 Ereignisse ausgelöst hast, bevor also das Ereignis,
ich habe den Knopf an der richtigen Stelle gedrückt, ausgelöst wird.
Das ist das eine. Wir wollen die entgegennehmen, diese Ereignisse.
Und das zweite ist, wir müssen in einer,
in einer Klasse, die diese Ereignisse entgegennimmt,
also wollen wir von den zugrunde liegenden Ereignissen,
also das, was das Fenstersystem liefert,
möglichst schnell abstrahieren
Der Grund dafür ist, wir wollen uns in einer Klasse wie Überweise,
wollen wir uns nicht damit beschäftigen, also was da draußen gibt es ein Fenstersystem,
das will man ja gar nicht wissen,
oder womöglich noch, also welcher Art die Ereignisse sind,
die da ankommen, das interessiert einen alles gar nicht.
Wir wollen die Fachlichkeit auf der einen Seite haben und die Technik auf der anderen Seite,
weil, sagen wir mal so,
das Konzept des Kontos gibt es ja schon so seit ein paar hundert Jahren,
also dass man das also interaktiv an einem Computer manipulieren kann,
das ist noch so eine relativ frische im Vergleich ich dazu,
also eine relativ frische Geschichte,
dass sie heutzutage mit ihren Mobiltelefonen irgendwas mit ihrem Konto machen können,
machen wollen.
Also sei mal dahingestellt. Also die wollen die fachlichen und
die technischen Angelegenheiten wollen wir voneinander, wollen wir voneinander trennen.
Das heißt, wir müssen von diesem Fenstersystem,
also in diesem interaktiven Kontext Fenster, wo ein Fenstersystem eine Rolle spielt,
müssen wir abstrahieren.
So, wie machen wir das jetzt
Also, wir brauchen eine Klasse, mit der wir diese ganzen Interaktionsspezifischen Aufgabenstellungen lösen.
Wir brauchen eine Klasse, die die eigentliche Fachlichkeit implementiert.
Und jetzt sehen Sie das jemals,
dass so der verzweifelte Versuch so mit unserem Cutter,
mit meinen, sollte ich in diesem Fall sagen,
Mitteln des Kartoffeldrucks, also klar zu machen,
also wie denn jetzt hier so der Fluss der Ereignisse,
der Strom der Ereignisse ist.
Hier ist also dieser Benutzer, der wild mit der Maus irgendwas macht.
Und diese Ereignisse sollen bei einer Klasse namens Interaktion ankommen.
Und wenn die dann sagt,
Also der Überweisenknopf gedrückt worden und in dem Betragsfeld steht 1.500 drin,
dann soll diese Information in abstrahierter Form an die Klasse Überweiser gehen.
Das heißt also, die natürliche Richtung der Benutzung ist also von Interaktion hin,
also zur Funktionalität, also in diesem Fall, dass die Klasse Überweiser.
Technisch, die benutzt Beziehung und die Vererbungsbeziehung haben sie ja
bereits kennengelernt, also die Benutztbeziehung läuft jetzt hier so,
die Interaktion kennt den Überweiser.
Das ist ja so weit,
so unkritisch
Jetzt hat es möglicherweise, ist es dazu gekommen,
dass diese Überweisung erfolgreich durchgeführt wurde. Und jetzt will man,
mindestens will man auf dem Konto des Überweisenden,
also des Auftraggebers, will man auch sehen.
Also da ist jetzt weniger drauf. Weil man will ja
jetzt nicht einen falschen Zustand, also wieder gespiegelt bekommen.
Das heißt, irgendwie muss es diese Klasse über Weiser schaffen,
also der Interaktion zu sagen, ein Moment bitte,
der von dir im Moment angezeigte Konto stand, ist nicht mehr aktuell.
Ich habe hier einen neuen Kontostand, sondern der muss jetzt
an der Oberfläche angezeigt werden. Das, denke ich,
ist also eine erwartungskonforme, oder das wäre ein erwartungskonformes Verhalten.
Wie kriegen wir das jetzt hin, beziehungsweise wo besteht jetzt
das Problem? Es ist ja so, wir machen jetzt
erstmal ein Problem daraus
Und so wie das da steht,
würde das eine zyklische Benutzung zwischen den Klasseninteraktionen und Überweiser bedeuten.
Jetzt sollte ich doch dieses Storesi-Ding hier haben.
Jetzt mache ich es mal klassisch mit Handzeichen,
ist die zyklische Verwendung von Klassen ein Problem oder kein Problem?
Also wer ist für, es ist ein Problem?
Wer ist dafür, dass es kein Problem ist?
Was gibt es denn da zu lachen
Ja, so ein kleines Problem oder ein großes Problem.
Also sie halten das nicht für problematisch. Warum nicht?
Ja. Also der Kollege behauptet also, nein,
das ist jetzt eine tendenziöse Formulierung, der Kommilitone führt aus,
solange es nicht zu endlos Rückkopplungen kommt,
ist es eigentlich kein großes Problem
Kann man so sehen. Und ich sage Ihnen mal,
also es gibt in vielen Systemen da draußen in der Praxis,
also gucken auch viele Leute genau so da drauf.
Das halte ich für beherrschbar an der Stelle.
Das ist jetzt eine effiziente Herangehensweise. Der Überweiser möchte
der Interaktion was sagen und das Einfachste ist,
so er tut es dann auch einfach.
Und wissen Sie, was das Allereinfachste ist?
Wieso sollen wir da jetzt zwei Klassen draus machen?
Wir lösen das Rückkopplungsproblem dadurch, dass es genau eine Klasse gibt.
So, jetzt kannst du kommen. Jetzt haben wir nämlich
keinen Rückkopplungsproblem mehr. Das kann man auch machen.
Das ist das Wunderbare an der Softwareentwicklung.
Man kann eigentlich alles machen. Man muss jetzt mal
ein paar Kriterien anlegen
Oder was man ja tun kann, um also so eine
Entscheidung zu motivieren, mache ich alles in eine Klasse.
Dann habe ich zwei Klassen mit wechselseitiger zyklischer Benutzung.
Oder muss ich mir was drittes, komplizierteres überlegen?
Ist ja abhängig davon, also was man, sagen wir mal,
mittel- und langfristig für Ziele hat. Wenn man das Ziel hat,
eine langfristig wartbare, verständliche Lösungen herzustellen, dann ist also,
eine Klasse ist keine Lösung und zyklische Benutzung ist auch keine Lösung.
Weil das Zeug ist auf Dauer nicht wartbar. Und das,
da ist ein ziemlich einfacher Zyklus. Wenn es dann Zyklen werden,
also die, wo es so eine Kette von,
sagen wir mal, 30 Klassen ist,
also die sich benutzen und die erst ganz am Ende gibt es wieder jemanden,
der das nach vorne, vorne so eine rückwärts Referenz hat,
Das kriegen sie technisch, also dann kriegen sie ohne technische Unterstützung,
kriegen sie das schon gar nicht mehr raus.
Das wird in dem Moment ein Problem, wo sie dann sagen,
na gut, ich möchte jetzt mal von einem Prozess,
möchte ich das mal verlagern, in zwei Prozess.
Und dann stellen sie fest, oh, das geht gar nicht,
weil ich muss immer das ganze Ding, muss ich bewegen.
Ansonsten, also habe ich also einen einzigen,
wie kann man das hübsch ausdrücken?
Was ich auf der Zunge habe, ist also ein Klumpatsch,
das ist beliebig unwissenschaftlich. Positiv formuliert könnte man sagen,
wir haben ein
hochgradig integriertes System
Was aber ein Euphemismus ist, genauso wie Entsorgungspark statt Atommülldeponie.
Das verschleiert eher, als dass es also aufklärt. Also lange Rede,
kurzer Sinn, zyklisch benutzende Klassen ist also des Bösen,
während den Anfängen, wir wollen das nicht,
die Gründe dafür werden wir ihnen im Rest ihres Studiums,
wenn sie Softwaretechnik hören und später vielleicht noch Software-Architecture im,
was hätte ich jetzt gesagt, Hauptstudium,
das heißt, der heutzutage Masterstudium,
also wenn sie das vielleicht noch hören,
das Thema wird sich wiederholen
Das Rückkopplungsproblem, das werden wir jetzt lösen. Aber danke für den Hinweis,
wenn ich die Frage nochmal stelle, sollte ich,
also die Rückkopplungsfrage sollte ich dahin schreiben, nicht das Rückkopplungsproblem.
So, erster Vorschlag, um also dieses Problem zu lösen,
ist, also Sie sehen jetzt schon,
die Grafik sieht viel einfacher aus als vorher, die Interaktion,
die gibt jetzt nicht nur den Strom von Ereignissen an den Überweiser,
sondern so, jetzt ist Ist man ja schlau.
Die Interaktion sagt, okay, ich habe jetzt gerade also
die Operation überweisen, am Überweiser aufgerufen.
Ich weiß ja, dass das einen Effekt erzeugt. Nämlich,
erstens, auf dem einen Konto ist weniger, zweitens,
auf dem anderen ist mehr. Also frage ich jetzt mal
direkt nach. Gib mir mal die beiden neuen Kontostände.
Die sondierenden Operationen stellt er über, was steht denn da überhaupt?
Überweise, das ist auch schön. Ich glaube,
ich kann diese Vorlesung noch 20 Jahre halten und noch viel mehr
andere Betonung noch 20 Jahre halten und finde immer noch Fehler.
Ich kenne ja die Effekte dieser Aufrufe. Also frage ich
direkt nach, wo ist da das Problem in dieser Lösung?
Steht hier schon das Geheimnisprinzip, ist verletzt. Wir haben ja extra gesagt,
Interaktion, deine Aufgabe ist die Abstraktion vom Fenstersystem,
nicht irgendwas, also mit Fachlichkeit.
Das sollst du nicht. Das liegt alles beim,
in diesem Fall bei der Klasse Überweiser.
Also war ein netter Versuch, aber der ist noch
nicht ausreichend
Jetzt muss ich einen kurzen Einschub machen. Das ist ein weiteres Thema,
wenn Klassendiagramme, haben Sie so als eine Art von Diagramm
der Unified Modeling Language, also der UML, schon kennengelernt.
Jetzt zeige ich Ihnen eine andere Art von Diagramm,
weil die einen Ablauf in einem objektorientierten System kann man mit
einem Diagramm wie im Klassendiagramm nicht darstellen.
Da brauchen wir eine andere Art von Diagramm und das ist hier der Fall.
Da sehen Sie die UML-Sequenzdiagramme. Wie liest man sowas?
Das geht beruhigenderweise geht es links oben los und dass jeder,
jeder, wo muss jeder Stab hier oder jedes dieser Rechtecke, das ist ein Objekt. Und jetzt gibt es also irgendwie Zeit,
die verläuft hier vertikal und man liest es dann so,
ein Objekt ist dafür verantwortlich, ein anderes Objekt zu erzeugen,
aber wenn es das getan hat,
dann kann ein Objekt eine Operation an diesem neuen Objekt aufrufen,
dass wir dieses Objekt ruft, jetzt was an sich selbst auf,
dann geht der Kontrollfluss zurück an dieses Objekt,
das wird durch diese Art von Pfeilen,
wird es so dargestellt und dann hat dieses neue Objekt offensichtlich
seine Schuldigkeit getan und es wird wieder gelöscht
Also wenn man sich mal vergegenständlichen möchte,
wie ein bestimmter Ablauf zwischen Objekten, wie der funktioniert,
dann kann man das mit einem UML-Sequenzdiagramm, kann man das darstellen.
Generell hat es also zwei Dimensionen, so eine Sequenzdiagramm,
nämlich vertikal wird die Zeit. Also die Zeit dargestellt,
horizontal sind die an einer Operation beteiligten Objekte dargestellt.
So und dann kann man jetzt, das können Sie nachlesen,
was da so jetzt so im Einzelnen steht,
auch nicht mehr viel mehr als das,
was ich Ihnen jetzt auf der Tonspur schon gesagt habe.
Wir können uns jetzt also bei diesen beiden beteiligten Objekten mal anschauen,
wie sieht da, also die Kommunikation zwischen diesen beiden Objekten aus.
Für den Lösungsansatz, den ich gerade dargestellt habe.
Also die Interaktion ruft an dem Überweiser die Operation überweisen auf,
dann geht brav der Kontrollfluss zurück. Und dann, das ist jetzt,
also da kann jetzt also der Sherlock Holmes in ihn,
kann jetzt also feststellen, da weiß also die Interaktion,
was über Effekte, die in der Funk,
bei dem Überweisen ausgelöst worden sind, wie kommt die Interaktion darauf,
jetzt das Auftraggebersaldo nachzufragen.
Da ist der Hund dieser Lösung begraben,
also da muss offensichtlich Kenntnis darüber vorhanden sein,
dass also irgendwas da eben dem Überweiser,
also funktional fachlich passiert ist
Und das soll nicht sein. So. Schade auch. Und könnten wir jetzt,
wenn das die Lösung wäre, könnten wir jetzt Feierabend machen, ist noch nicht ganz.
Lösungsansatz 2. Es geht jetzt so in die Richtung,
das ist so die echte zyklische Benutzung. Die Funktionskomponente,
also das ist jetzt eine etwas andere Begrifflichkeit,
die Funktionskomponente, also unser Überweiser, Funktionskomponente deswegen,
weil es also die Funktionalität implementiert, sagt am Ende eines Operationsaufrufs,
ah, mein Zustand hat sich geändert,
also rufe ich jetzt mal die Interaktionskomponente,
sprich also die Interaktion kurz,
die Interaktion auf und sage dann,
Das ist also genau, hier hängt dieses Atomzeichen jetzt. Deswegen,
weil die Funktionalität, der Überweiser soll gar nicht wissen,
dass da überhaupt jemand ist, der sich dafür interessiert.
Und wenn das so ist, also dann soll das nur wissen,
also so im Sinne von, also wenn das jemand darstellen möchte,
bitteschön soll er das tun, aber dass da überhaupt jemand ist,
der das in einer bestimmten Art und Weise darstellt,
das braucht also die Funktionskomponente, sprich also der Überweiser erst recht nicht wissen.
Wie würde das so diese Art von Verbindung zwischen Interaktionen und Überweiser dann aussehen,
so der Überweiser, also die Interaktion ruft über Weisen auf und zack,
jetzt liegt der Kontollfuß halt hier und der sagt also sowas an der Interaktion,
wie aktualisiere Empfängersaldo, als wenn der weiß,
also so macht man Annahmen darüber,
dass der das jetzt tatsächlich darstellen will, dass er blühender Umfug,
also so viel Kenntnis über seine Umgebung darf unser Überweiser einfach nicht haben.
Also das ist es auch nicht
Jetzt kommen wir der Lösung, also viel mehr kaputte Ansätze,
zeige ich Ihnen jetzt auch nicht.
Viel mehr gibt es da, glaube ich, auch nicht.
Jetzt geht es langsam so in diese Richtung ineinander greifende Zahnräder, alles wird gut.
Jetzt sehen Sie das Prinzip, den prinzipiellen Lösungsansatz. So,
jetzt habe ich, vorhin habe ich gefragt, also über Sie erfahren,
keiner von Ihnen studiert im Nebenfachmedizin, studiert von Ihnen,
nein, erste Frage, gibt es hier englische Muttersprachler?
Gibt es nicht. Gibt es jemanden,
der Anglizistik
im Nebenfach studiert
Gibt es jemanden, der einen englisch-muttersprachlichen Lebensgefährten, Lebensgefährtin hat?
Das ist dieser Hamburger, echt. Provinz. So,
okay, also sie sehen, also der prinzipielle Lösungsansatz für denjenigen,
der wie mich, also deutsch-muttersprachlich ist, da steht Polling,
der Polling-Ansatz.
Jetzt habe ich das dann immer so gesagt,
bis mir dann mal so ein Englisch-Muttersprachler sagte,
wir sagen dazu Polling
Aha. Nicht Bowling, sondern Powling. Ich möchte jetzt schon das dritte,
was ich Ihnen für den Rest Ihres Berufslebens mitgeben möchte, der Powling-Ansatz.
Kommen Sie mir nicht in eine mündliche Prüfung und behaupten,
dass das Polling heißt, was da passiert.
Ich verstehe das schon. Dann können wir drüber reden.
So, also, aber was ist Powling? Das steht da oben drüber,
nämlich die Interaktionskomponente, so stellt sich jetzt dumm.
Sie soll ja nichts wissen über die Effekte,
die sie erzielt.
Also,
was macht sie
Sie macht jedes Mal nach jedem Systemereignis steht da,
ruft die Interaktion einfach alles an sondierenden Operationen in der zugeordneten Funktion,
also in dem Überweiser, in unserem Fall auf.
So, hat sich der Kontostand des Auftraggebers verändert.
Hat sich der Kontostand des Auftragnehmers verändert. Welchen Betrag
soll ich darstellen oder welchen Betrag soll ich hier darstellen?
Ich betrage es euch darstellen. Das ist das
ständige Aufrufen von sondierenden Operationen
Und das bezeichnet man dann auch. Also so diese Herangehensweise,
dieses ständige Sondieren, das ist das,
was unter diesem wunderschönen Begriff des Powlings so verstanden wird.
So, das ist softwaretechnisch, ist es total sauber.
So, weil weder der Nachteil der ersten Lösung,
nämlich die Interaktion, der muss was, also wissen,
dieser Nachteil ist weg und die Funktion braucht auch nichts zu wissen.
Weil man wird ja einfach immer nur gefragt.
Und wer da fragt, ist also,
ist also der Funktion, dem Überweiser auch unbekannt.
Also insofern ist das gut. Jetzt steht hier noch
Die Interaktion ist fast ausschließlich mit Powling beschäftigt.
Ja, das stimmt. Das ist, so wenn man
so will, das ist das Gegenteil von Green Computing.
Da erzeugt also jede Menge Arbeit. Man fragt auch an
Stellen nach, also wo man überhaupt nicht nachfragen muss.
Man sorgt einfach nur für Beschäftigung. Weil es wird ja
immer nachgefragt. Das ist insofern ist diese Lösung zwar effektiv,
sie ist korrekt gegenüber einer Spezifikation,
aber sie ist nicht
sehr effizient
Ist, dass es nach so einem Kriterium,
wie viel Leerlauf haben wir denn da jetzt eigentlich?
Also ist das noch nicht so der Weisheit letzter Schluss.
Aber so prinzipiell wollen wir diese Lösung beibehalten.
Wie immer schauen wir uns das jetzt an.
Also wie schaut das aus? Also so im Sequenzdiagramm,
da wird also überweisend, wird aufgerufen.
Bis hierhin sind die Geschichten immer gleich. Und dann kehrt
der Kontrollfluss zurück. So und jetzt kommt der große Unterschied.
Jetzt werden also die Prädikate werden jetzt abgefragt und sagt,
dann gibt es hier halt
einen Rückgabewert
Hier gibt's ein Rückgabepferd, ach, der guckt mal,
der Auftraggeber Saldo hat sich verändert, dann gib mal überall den Auftraggeber Saldo.
Hat sich der Empfängersaal da verändert, in der Tat.
Also, gebt den Empfängersaldo her. So,
und das ist jetzt so die Grundidee, die wir jetzt
so ein bisschen weiter, die wir jetzt musterartig weiterentwickeln werden.
Wie kann man dieses erwünschte Verhalten, nämlich,
dass die beiden Komponenten voneinander unabhängig sind,
wie kann man dieses erwünschte Verhalten, das sich als effektiv gekennzeichnet habe,
wie kann man das jetzt auch noch effizient machen?
So, und die Grundidee dabei ist der sogenannte Benachrichtigte Beobachter
Wir haben also jetzt so das Verhältnis zwischen Interaktionen und Überweiser
, ist also ein ständiges Beobachten. Beobachten bedeutet es,
hat sich was geändert, hat sich was geändert und dann war es
jetzt sich geändert und dann frage ich das halt nach.
Und das möchte ich nicht mehr ständig machen, sondern ich möchte das nur noch machen,
wenn ich benachrichtigt werde, dass sich etwas geändert hat.
Deswegen also der Benachrichtigte Beobachter. Und das ist jetzt die Stelle in der Vorlesung,
wo ich also seit einigen Jahren frage, eines geneigte Publikum,
wer sagt zu wem, in welchem Film geben sie ihm ein einzelnes Ping.
Erstmal, wer weiß ist, 1, 2, 3, 4,
ja, sie hatten sich zuerst gemeldet. Ja. Ja. Ja,
weiß man, also das sind,
ja, das sind solche, also der Film ist,
die Jagd auf Roter Oktober,
so keine cineastische Besonderheit,
also es geht ja so um U-Boote und so und ist jemand auf so einen Knopf drück und dann macht es,
also in dem einen U-Boot Ping und der andere denkt,
also entweder ist der jetzt total dämlich oder sehr schlau
Sodass für mich der Seiteneffekt dieser Frage ist,
also früher könnten den fast alle den Film.
Heutzutage kenne ich ihn kaum noch jemand. Wenn ich so sagen darf,
sie schauen mir auch nicht gerade wie 20 aus. Ja,
ja, ja, das ist, also formal ist es ja,
also sind wir uns da einig, ja.
Ja, so, ja, okay, gut,
das war nicht persönlich gemeint. Ja,
also geben Sie ihm ein einzelnes Ping, die Grundidee,
der Überweiser soll also zu jemandem in seiner Umgebung sagen, Ping.
Und dann soll der Beobachter das als Nachricht verstehen,
um fragen zu können, so, was hat sich denn nur geändert?
Das ist das Grundprinzip des Benachrichtigten Beobachters und die Interaktion kann nachfragen,
weil sie ja diese ganzen sondierenden Operationen des Überweisers aufrufen kann.
So, das ist so von der Grundidee und jetzt steht hier,
wenn wir das machen wollen, dann muss die Interaktion im Überweiser bekannt sein.
Und damit hätten wir eigentlich wieder die Lösung 2. Na gut,
ja, aber wir nehmen das mal in Kauf,
weil das nur eine sehr schmale Schnittstelle ist.
Und die Lösung, die ich Ihnen gleich zeige,
viel macht dann noch eine weitere Abstraktion
Also es ist zwar im Prinzip so, dass wir hier eine wechselseitige Benutztbeziehung haben,
aber die ist nicht ganz so schlimm, wie die ursprünglich.
Und warum das nicht schlimm ist, denke ich,
werden wir sehen oder werden sie sehen,
wenn sie die eigentliche Konstruktion dann auch betrachtet haben.
Bevor ich die zeige, die eigentliche Lösung,
müssen wir uns noch mal kurz darüber unterhalten.
Also wie wir uns unterhalten. Ja. Was kann man
denn da eigentlich alles unterscheiden? Also das,
was Sie so aus der handelsüblichen, objektorientierten Programmiersprache kennen,
also in Ihrem Fall Java, ist,
dass es Calls gibt, also auf Deutsch Aufrufe.
So, wie ist so ein Aufruf gekennzeichnet? Der Aufruf ist dadurch gekennzeichnet,
dass der Aufrufende kennt den Aufgerufenen und er erwartet ein Ergebnis seines Aufrufs.
Das kann man also ziemlich genau sagen. Also sagen wir mal,
ich rufe sie auf und wenn ich sie etwas frage,
dann erwarte ich eine Antwort.
Das ist schon mal so ein ganz klares Verhältnis.
So könnten wir jedenfalls unser Verhältnis beschreiben. So,
was anderes ist es, wenn wir von einem Ereignis in
diesem Kontext sprechen. So, ein Ereignis, das wird ausgelöst
Und dann ist es ausgelöst. Und jemand, der möchte,
kann auf dieses Ereignis reagieren, aber derjenige,
der das Ereignis gesendet hat, kann keine Reaktion erwartet erwarten.
Sondern man hat einfach gesagt, ping, und das war's das,
aber es ist eben eine andere, hat eine andere Bedeutung,
als wenn ich jemanden aufrufe.
Insbesondere kann ich also keine Reaktion erwarten. Beim Ereignis steht
jetzt da, dass es an einem bestimmten Empfänger weitergeleitet wird.
Und das macht nochmal einen Unterschied,
zu dem der letzten eine Art von,
also sich mit der Welt auseinanderzusetzen,
das ist das Signal auf Neudeutsch, Englisch, der Bordcast.
Ich sende etwas, zum Beispiel ein Ping,
in einem mir unbekannte Umgebung. Ich weiß gar nicht,
ob da irgendjemand ist, der also dieses Signal hört.
Das ist nochmal anonymer, als also die,
als das Ereignis
In Zeiten, wo diese Sachen hier übertragen werden,
sage ich das natürlich nicht mehr öffentlich.
Und jetzt hoffe ich, dass da draußen Leute sitzen,
die sich fragen, was hat er jetzt erzählt?
Kann ich nur sagen, kommen Sie live und direkt hier
hin,
kriegen Sie
das volle Programm
Einen kleinen Vorteil müssen sie ja auch haben, auch wenn
der Witz nicht so gut ist, aber naja gut.
So, was wir also ausdrücken wollen,
worüber wir uns konzeptionell jetzt gerade Gedanken gemacht haben,
ist, der Überweiser möchte an eine ihm völlig unbekannte Umgebung
ein Signal ausstreuen
Was da heißt, an meinem Zustand hat sich etwas geändert.
Falls jemand diesen veränderten Zustand, also zu irgendetwas braucht,
zum Beispiel, um ihn an einer interaktiven Oberfläche darzustellen,
dann kann er oder sie jetzt meine sondierenden Operationen aufrufen und dann sage ich,
was ist mit meinem Zustand so auf sich hat.
Jetzt habe ich gerade extra gesagt, die handelsüblichen,
objektorientierten Programmiersprachen und insbesondere, also Java haben kein Ereignis- oder Signalmechanismus.
Das verhält sich bei moderneren, ja,
kann man glaube ich so sagen,
bei moderneren objektorientierten Programmiersprachen ist das
schon anders
So einer Sprache wie Java oder C Plus
Plus müssen wir diesen Signalmechanismus, müssen wir den nachimplementieren,
weil wir nur den Mechanismus des Calls haben,
um also einen Anbieter von einem Nachfrager miteinander in Verbindung zu setzen.
Und das machen wir so. Sehen Sie jetzt die prinzipielle Struktur
des Benachrichtigten Beobachters und dass diese Struktur hat zwei Elemente.
Das sind nämlich der Beobachter,
dass es ein Interface in Java und eine Klasse,
eine abstrakte Klasse namens Beobachtbar
Wir fangen mal so bei dem Beobachter an.
Also wenn Sie einen Beobachter von jemandem sein wollen,
also sowas wie unsere Interaktion, dann müssen Sie dieses Interface implementieren.
Das ist Interface zu implementieren, bedeutet, dass Sie eine einzige Operation implementieren müssen.
Und die heißt beachte Änderung. Das heißt,
als Beobachter bereiten Sie sich darauf vor,
dass Sie mit, also dass Sie von jemandem,
also bei dem Sie sich später noch zu registrieren haben,
dass Sie von diesem jemand aufgerufen werden mit der Operation beachte Änderung.
Ja, bitte
Ja, das sollte er. Da komme ich später zu
. Fein beobachtet, wie ich das so sagen darf.
Ja. So, also, beachte Änderung. Diese Operation
muss er implementieren. Die einfachste Art, diese Operation zu implementieren,
ist, zu implementieren, ist, ich tue nichts.
Das ist die Standard-Implementation, die manchmal auch vorgegeben wird. So,
das können Sie so bei Interaktiven,
also wenn Sie sich demnächst so mit Graphical User Interfaces beschäftigen werden,
So werden sie sehen, dass also die Standardreaktion eines Knopfes,
wenn er gedrückt wird, ist nichts.
Du kannst das oft draufhauen, wie sie wollen.
Sie müssen das Verhalten dann, also wenn sie benachrichtigt werden,
das müssen sie schon, müssen sie dann implementieren.
Was soll da passieren? So,
und dann können sie dann halt so unfassbar lustige Sachen machen,
wie wenn das Ding dreimal innerhalb von einer Sekunde gedrückt wird,
dass sie ihnen dann so fünf Zentimeter nach links verschieben.
So irgendwas. Ja, ich habe mal so in den frühen Zeiten,
es ist ja Ihnen ja sozusagen die Gnade der späten Geburt widerfahren.
So gab es also für den Mac,
da gab damals auch schon, die sahen ein bisschen anders aus,
gab es also so Bildschirmschoner, die ungefähr so genau einmal witzig waren,
also da stand dann so die Meldung, so nach zwei Minuten,
Dute to and Unexpected error, all your files were removed, Click-OK to continue.
Guckt man da drauf und denkt, oh Gott,
ja alles weg, letzte Datensicherung,
dann bewegt man sich also mit der Maus auf den OK-Knopf,
wenn man genau drüber ist, schiebt sich das Ding weg und macht halt so.
Ich fand den gut, also finde ich immer noch gut,
aber der klappt eben genau einmal, so der Witz,
so und sie kennen den jetzt auch schon
Also so dieses Verhalten, da hat also jemand diese
beachte Änderungsoperation, hat er die interessant, also implementiert.
Also wenn Sie Beobachter von jemand sein wollen,
dann müssen Sie diese Operation implementieren.
Und jetzt kommen Sie. Also ist es nicht auch interessant,
Bärder Ping gesagt hat. Das ist ja auch schon die Frage,
wer ruft mich denn jetzt eigentlich oft?
Kann mich jetzt hier jeder aufrufen, wenn ich beachte Änderung implementiert habe?
Nein. So, da ist, nehmen Sie sich bei
der Hits auf der anderen Seite die abstrakte Klasse beobachtbar.
Da kann man also insbesondere sagen,
Sätze beobachter
Da kann man jetzt einen Parameter übergeben und das ist derjenige
in der Regel, der also diese Operation beachte Änderung auch implementiert.
Sie können auch jemand anders da als Parameter übergeben,
aber das ist, also der dieses Interface implementiert,
aber das sind dann schon Spezialfälle. Also beobachtbar bedeutet,
also jeder, der beobachtbar sein möchte, muss diese abstrakte Klasse,
muss von dieser abstrakten Klasse erben und der verwaltet dann,
also jeder, der beobachtbar ist, nicht nur einen Beobachter,
sondern so wie das da steht,
eine Menge von Beobachtern
Dazu muss es eine Operationssätze,
Beobachter geben und die realisiert das dann, dass man sich,
also die Beobachter, die sich bei einem angemeldet haben,
weil sie eben benachrichtigt werden wollen,
wenn sich eine Änderung im Zustand, also des Beobachtbaren Objektes ergibt,
weil dann sollen die halt alle benachrichtigt werden.
Wie geht das? Dazu implementiert die abstrakte Klasse beobachtbar,
eine Operation namens Meldeänderung, das ist irgendwie einfach,
also die geht halt,
die iteriert über der Menge,
also der Beobachter,
die sich angemeldet haben bei der beobachtbaren Klasse
Da wird eben, da sehen Sie auch diesen Aufruf, das beachte Änderung.
Das ist genau die Operation, die, also die Beobachter implementiert haben.
So, das sind also Beobachter und Beobachtbar, dieses Verhältnis.
Und jetzt sehen Sie das im Zusammenhang mit dem Überweiser.
Die Interaktion, die ist in unserem Fall der Beobachter.
Der muss also die Operation beachte Änderung implementieren.
Und was sagt die dann hier? Naja,
die sagt also zu dem Überweiser, den sie kennt,
sagt sie halt, dann gib mir mal deinen Zustand,
das ist jetzt Pseudo-Code.
Sie haben an dem Überweiser keine Operationen, gibt Zustand,
sondern eben so irgendwas von der Art hier,
die sondiert werden kann, was sich da eigentlich geändert hat.
Und dann zeigt sie das in irgendeiner Art und Weise an.
So, das ist das Spiel, also auf der Seite des Beobachters.
Also auch nicht, also intellektuell eigentlich nicht besonders aufregend.
Das einzige, was also eine beobachtende Klasse tun muss,
ist, sie muss also die Operation beobachten,
beobachte Änderung.
Beachte Änderung, implementieren
Wie sieht das auf der Seite der Beobachtbaren, Klassen aus?
Nun, sie erben von der Klasse beobachtbar. Und jedes Mal,
wenn sich also hier etwas im Zustand geändert hat,
dann rufen sie an ihrer Oberklasse die Operation Meldeänderung auf.
Und dann rufen sie Meldeänderungen auf und sie wissen nicht,
was passiert denn da jetzt eigentlich? Außer,
also alle meine Beobachter, die werden jetzt mit Beachteänderungen aufgerufen,
dann sind sie, was den Kontrollfluss anbetrifft, wieder hier.
Und irgendjemand, der also diese Operation beachte Änderung so implementiert hat,
wie er das so richtig hält,
wird dann schon die Sondierenden
Operationen aufrufen
Und damit haben wir diesen Kreis jetzt wieder geschlossen.
Und zwar auf eine Art und Weise, die es also ermöglicht,
also der Überweiser, der weiß jetzt überhaupt gar nichts davon,
dass es eine Interaktion gibt.
Der Überweiser, weiß eigentlich nur,
also ich bin beobachtbar und wenn mich jemand beobachtet,
dann kriegt er das jetzt mit, dass ich an meinem Zustand etwas geändert hat.
Und genau das ist das, was ich erreichen möchte.
Ich habe davon gesprochen, ich erwarte keine Reaktion von jemandem,
wenn ich ein Ereignis aussende.
Und ich sage einfach nur, es hat sich ein Ereignis
Es ereignet. Es hat ein Ereignis gegeben. Und wenn sich jemand dafür interessiert,
dann habe ich ihm jetzt die Möglichkeit gegeben,
also sich so zu erkundigen, was ist denn nur eigentlich los?
Und das ist die Konstruktion mit Beobachter und Beobachtbar.
Jetzt gucken wir uns das wieder. Gucken wir uns das
wieder im Sequenzdiagramm an. Das ist jetzt eine weitere Lieblingsstelle von mir.
Sie haben mich, sehen wir ja schon darauf hingewiesen,
also so die Interaktion muss jetzt erstmal sagen, hallo,
liebes, beobachtbares Objekt,
ich bin's
Und das sehen sie also in Code umgesetzt hier.
Wir wissen ja, dass es am Objekt überweiser,
weil es eben eine Unterklasse der Klasse beobachtbar ist.
Gibt es die Operation, Sätze, Beobachter?
Da wird ein Beobachter übergeben, also dynamisch dann ein Objekt
vom Typ Interaktion, von der Klasse, Interaktion.
Was macht die? Der Beobachter übergibt sich als Parameter
Also da steht ja das, so ist, so liest man diese Stelle ja hier,
ich übergebe mich als Parameter der Operation Sätze Beobachter.
Das ist die objektorientierte Wendung in Jara für ich in anderen Sprachen. Current,
jeder hat da so seine eigene Diktion jedenfalls, also das,
ich übergebe mich als Parameter und dann hat der Überweiser halt diesen konkreten Beobachter,
hier steht jetzt Liste, wohin war es eine Menge,
ist ja auch egal, es kann auch ein Array sein,
kann sonst irgendwas sein,
von mir aus eine Q oder ein Stack oder einen Baum,
also wo man sich das jetzt gerade merkt,
dass es also eine Liste von Beobachtern gibt.
So. Und wenn dieser Beobachter da jetzt bekannt ist, dann sieht das so aus.
So, wie es immer losgegangen ist, aha, überweisen.
Und ziemlich direkt danach ruft der Überweiser dann,
also die Methode Meldeänderung, die er von seiner Oberklasse her kennt,
ruft er auf und das läuft in einen Aufruf von Beachteänderung bei dem registrierten Beobachter,
läuft es hinaus.
So, und jetzt kommt's
Weil die Implementation von beachte Änderung scheint offensichtlich einen Aufruf von,
ist Auftraggeber Saldo verändert zu beinhalten und noch so
ein paar anderen Sachen, so hier im Pseudo-Code.
Und dann ist irgendwann der Kontrollfluss wieder bei der Interaktion.
Und das ist jetzt so die Idee des Benachrichtigten Beobachtermusters.
Nein, nicht das Benachrichtigten. Das Benachrichtigten Beobachters. Und
das Verhalten, das also durch diese zwei Worte beschrieben wird,
wird auch als Beobachter Muster beschrieben
Dieses Beobachtermuster ist also eine Abstraktion von einer konkreten Problemsstellung,
die sich immer wieder im Programmieralltag stellt.
Und die Formulierung sehen Sie da. Also wenn es darum geht,
dass also Objekte wechselseitig synchron gehalten werden sollen, wie in unserem Fall,
also die Interaktion und der Überweiser, dann kann man dieses Muster verwenden.
Und das geht so, man definiert eine 1-zu-N-Abhängigkeit zwischen den Objekten,
sodass die Änderung des Zustands eines Objekts überweiser, dazu führt,
dass alle abhängigen Objekte, in unserem Fall 1,
nämlich die Interaktion, benachrichtigt automatisch aktualisiert werden.
Automatisch geht natürlich gar nichts. Das, was da passiert bei dem Automatismus,
ist, dass über diesen Zusammenhang von Meldeänderung und beachte Änderung
genau diese Synchronisation hergestellt wird oder die Möglichkeit zur Synchronisation hergestellt wird.
Und das ist jetzt eine Entwicklung, die hat sich,
wann lang ging es denn das her, Mitte der 90er Jahre des letzten Jahrhunderts,
hat sich also jemand hingesetzt, Erich Gamma heißt der,
ist immer noch aktiv und hat also seine Dissertation zu dem Thema geschrieben über Entwurfsmuster.
Was der, der hat damals bei einer Organisation gearbeitet namens Ubi-Lab,
das war das, Union Bank of Switzerland, Informatics Labritory.
Also wenn sie so wollen, so ein Think Tank,
also den es damals noch gab, also wo wirklich,
also extrem weitreichende, informatische,
softwaretechnische Lösungen gefunden worden sind und unter anderem eben auch,
also die Idee der Entwurfsmuster,
sprich,
also wir haben,
wir sehen uns hier so vor einem wiederkehrenden kleinen Problem und
wir beschreiben jetzt mal grundsätzlich,
wie man
dieses Problem lösen kann
Und diese Problembeschreibung, die nennen wir dann ein Entwurfsmuster und in diesem Fall,
was sie gesehen haben, ist, dass das Entwurfsmuster beobachtet haben.
Und ab heute können sie jetzt also für den Rest ihres Berufslebens,
können sie, wenn sie so vor einer programmiertechnischen Fragestellung stehen,
also die sie so halbwegs gerade formulieren können,
das sollte schon sein,
dann können sie jetzt in die Bibliothek gehen und dann schnappen sie sich das entsprechende Buch,
zeige ich ihnen gleich noch und gucken mal,
ob es für dieses Problem,
das sie haben,
ob es dafür
eine prinzipielle Lösung gibt
So eine Lösung, die schon mal jemand für sie implementiert hat, grundsätzlich.
Da gibt es nämlich sogenannte Musterkataloge. Das ist so wie
Schnittmuster für selbst, also sich irgendwelche Hemden oder sowas schnipseln.
Also gab es früher jedenfalls mal. Also ich weiß
gar nicht, ob es das immer noch gibt.
Habe ich eh nie benutzt. Genauso gibt es, also
Musterkataloge für solche Programmierprobleme. Und das ist also das Beobachtermuster,
ist so eins der berühmteren Muster, weil das gerne,
also gerne genommen wird, um, also genau das Problem,
eins zu N-Abhängigkeitssynchronisationen von Objekten, dass diese Fragestellung ergibt sich häufig in Programmiersprache,
also in softwaretechnischen Problemstellungen, um diese Probleme zu lösen.
So, das war also ein Entwurfsmuster, nämlich das Entwurfsmusterbeobachter.
So, wenn ich sage, ein Entwurfsmuster,
dann ist der Verdacht ja nahe, dass es also mehrere Entwurfsmuster gibt.
Ich habe jetzt auch schon von Musterkatalogen gesprochen.
Und jetzt müssen wir uns kurz klar machen,
was ist das so ein Muster?
Abstraktion von einer konkreten Form. Das heißt also,
wenn man einmal das Problem konkret gelöst hat,
tritt man einen Schritt zur Seite und sagt,
was habe ich denn jetzt eigentlich getan
Dann kann man das Musterartige in dieser Lösung erkennen,
die wiederholt in bestimmten, nicht willkürlichen Kontexten auftritt.
Ja, so ist das. Also so ist das,
so das Konzept des Musters definiert. Und diese,
diese Muster, da gibt es jetzt eine ganze Reihe von,
also sagen wir mal, ähnlichen vergleichbaren Definitionen.
Also Solution to recurring, also eines sich wiederholenden Problems in
einem Kontext. Allgemeiner kann man es wohl nicht,
also definieren
Kurz noch dazu diesen Ausflug, also das haben sich Informatiker,
Softwareentwickler, Softwaretechniker auch nicht selbst ausgedacht,
also diese Art, also eine konkrete Art schon,
aber so diese Herangehensweise stammt so aus der Architektur,
also aus der richtigen Architektur, so Häuslebäumen,
aus dem Häuserbau, Hausbau und der Architekt, der so damit,
also auch innerhalb der Architektur so Berühmtheit erlangt hat,
ist also Christopher Alexander und der hat das eben,
also hat es eben, wie man an dieser Definition sieht,
also schon, oder sollte man auch sagen,
erst in den 70er Jahren oder Architektur gibt es ja dann auch schon ein paar tausend Jahre länger,
aber der hat eben auch so einen Musterkatalog, also entwickelt,
indem er also sagt,
also was ist das Problem,
was ist das Problem von Hamburg?
Es regnet immer, was können wir da machen?
Wir machen Arkaden. Dann kann man nämlich im Regen auch einkaufen. Wenn man das als Architekt,
das liegt jetzt irgendwie so auf der Hand, dass man das macht,
aber das ist genauso die Grundidee, die wir,
also die die so in diesen Musterkatalogen von Christopher Alexander drinsteht.
Also ob es so eine heiße Region sind oder so,
wenn es immer stürmt oder so,
dass man also so bestimmte Patterns hat,
also mit denen man also so ein Problem,
dass man so vor sich sieht als Häuslebauer, also grundsätzlich lösen kann.
Und dann ist das passiert, Gott sei Dank sind
die anderen auch nicht schlauer als die Softwaretechniker, Softwareentwickler.
Also das passiert, was passieren musste. Nämlich also die Welt der Architekten,
so greift nach diesem Buch von Christopher Alexander und dann bauen sie
Häuser nur noch so aus dem Musterkatalog und trotzdem ist es hässlich Unbequem, passt nicht.
Und das ist bei Softwareentwicklern genauso. Sie können nicht Software
nach Musterkatalog bauen und hoffen, dass dann alles gut wird,
sondern es ist genau andersrum.
Sie wollen ein gutes Stück Software bauen und dann gucken Sie,
welches Muster könnte denn helfen, um sie noch eleganter von innen zu bauen.
Also so rum. Die Hoffnung hatten wir auch mal eine Zeit lang,
dass wenn man Software nur noch nach Mustern baut,
dass dann die innere Struktur toll ist, aber ist leider nicht so.
Das kann man, also nicht im mathematischen Sinne, sagen wir mal,
Gedankengang, den kann man auch noch an vielen Stellen heutzutage nachlesen.
Es ist auf jeden Fall gut, diese Musterkataloge zu kennen.
Sie sind also weder notwendig noch hinreichend für gute Architektur,
aber es kann helfen, also komme ich gleich auch noch etwas detailliert dazu.
Also Entwürfe, also strukturierter zu machen und über diese Entwürfe
insbesondere auch strukturierter sprechen zu können oder effizienter sprechen zu können.
So, die Musterdiskussion hat sich dann also so in der Informatik
durch dieses Buch von Erich Gamma und anderen Also ist das wirklich losgetreten worden?
Und er hat in die Hand genommen, das Buch-Design-Patterns,
ist also, wenn nicht mittlerweile das, aber doch mindestens einzelne meistverkauften IT-Bücher überhaupt,
weil das ist wirklich wie so ein Tsunami,
also über die Softwareentwicklungsgemeinde ist es also drüber gerollt,
also im positiven Sinne ist sie davon erfasst worden.
Und deswegen ist es halt, denke ich, ganz wichtig,
dass sie das ja auch mal nahegelegt bekommen, weil sie werden sich,
also ob sie jetzt hier oder in Indien später Software entwickeln,
Entwurfsmuster, das Konzept der Entwurfsmuster kennen, glaube ich,
heutzutage alle, die sich mit, oder kennt jeder,
der sich mit Softwareentwicklung beschäftigt.
So, das von der Entstehung her ist das also jeweils so,
Bevor man also darauf kommt,
dass ein bestimmtes Entwurfsmuster hilfreich sein kann oder überhaupt etwas,
eine musterartige Struktur hat, ist es also die,
es ist notwendig, vorhandene Designlösung vorhandene Implementierung,
also zu überarbeiten und zu analysieren und das Problem auf seine Struktur zu bringen,
sodass man also das überhaupt als generelles Problem erkennt.
Und wenn man das getan hat, dann kann man auch sagen,
na um dieses Problem zu lösen,
also gibt es prinzipiell erstens diejenigen Klassen, das spielt eigentlich nur,
so Entwurfsmuster spielt nur im Objektorientierten Entwurf eine Rolle.
Die Klassen spielen dabei mit und zweitens, also das ist die Art und Weise,
wie sie miteinander interagieren, um dieses grundsätzliche Problem zu lösen.
Das ist also bei uns, insoweit das Muster,
das sie jetzt kennengelernt haben, das beobachten musste.
Es gibt also die beiden Mitspieler, in Anführungsstrichen,
beobachtbar und beobachter und die Art und Weise,
wie die miteinander interagieren, wie die miteinander zusammenhängen.
Das lässt sich durch das UML-Sequenzdiagramm lässt sich das beschreiben.
Und das ist also Das heißt, auch die Entwurfsmuster unterliegen einer musterartigen Beschreibung.
Und das gibt es jetzt in unterschiedlichen Ausprägungen, also das,
was da links steht, das ist so der minimale Satz von Elementen,
die so eine Musterbeschreibung typischerweise hat.
Also jedes Entwurfsmuster hat einen Namen. Da gibt es also so,
sagen wir mal, so ein halbes Dutzend,
Dutzend Entwurfsmuster werden sie jetzt so im Laufe ihres Studiums,
werden sie kennenlernen,
die sich auch,
also die so in praktischer Weise häufig eingesetzt werden
Problem, dass durch dieses Entwurfsmuster gelöst wird,
weil das ist ja das, was sie wollen,
wenn sie durch den Musterkatalog mal durchgehen, welches Problem wird hier eigentlich gelöst?
Ist das mein Problem oder könnte man das Problem,
das ich vor mir sehe, mithilfe dieses Entwurfs muss das lösen?
Also ist das ganz wichtig, dass das die Problembeschreibung dazugehört? Der Kontext,
so jede Lösung hat immer, es kommt mit einem neuen Problem daher,
das will man eigentlich auch nicht haben, aber naja gut,
also jeder ist Lösung, so ist auch gleichzeitig ein anderes Problem.
Also der Kontext, in dem sich dieses Problem, dass dieses Entwurfsmuster lösen will,
stellt, Die konkrete Lösung und vor allem, also welche Konsequenzen ergeben sich aus der Musteranwendung. So,
das kann man sich ja jetzt, also gerade was die Konsequenzen anbetrifft,
so kann man sich das ja auch mal so bei dem Entwurfsmuster beobachten,
so ganz kurz so vor Augen führen, die ursprüngliche,
also sozusagen, wenn sie die ursprünglichen Lösungen so vor ihrem geistigen Auge nochmal sehen,
da waren nur zwei Klassen beteiligt oder mit einer einfachsten Form ist es bloß eine einzige Klasse.
Nämlich also die Klasse, interaktiver Überweiser, Punkt. Das ist ein einfacher Entwurf. Aber wenn sie den Entwurf hier jetzt nochmal sehen,
Das ist schon ein bisschen mehr,
also was man da jetzt betrachten muss,
um so auf den ersten Blick, also für den Arzt,
also ergibt sich das relativ schnell, was da los ist,
aber so, wenn man sich da jetzt erstmal einarbeiten muss,
und das ist ja auch teilweise, sind das dann auch größere Zusammenhänge,
das ist schon ein gewisser intellektueller Aufwand, also den man spendieren muss,
um also diese Art von Separation of Concerns zu implementieren.
Und das ist also mindestens eine der Konsequenzen,
die sich jetzt gerade so aus der Anwendung,
also das muss das beobachten, das Entwurfsmusters Beobachter ergibt,
aber Dafür werden sie ja ausgebildet,
dass sie genau diese Entscheidung treffen können,
um sagen zu können, hier stehe ich,
ich kann nicht anders, ich muss das Entwurfsmusterbeobachter jetzt anwenden,
weil dafür werden sie ja schließlich hier ausgebildet.
So, jetzt kann man also,
das muss man eigentlich nur noch eine Unterscheidung machen,
also so dieser allgemeine Teil des Entwurfsmusters sagt dann also, das,
was ich gerade beschrieben habe, also was ist das Problem,
wie sieht die Lösung aus, was sind die Konsequenzen.
Das Entwurfsmuster am Beispiel des Entwurfsmusters Beobachter kann man aber auch noch einen weiteren Teil,
also jetzt hineindifferenzieren, nämlich Wie wird das,
was prinzipiell als Lösungsidee für dieses Entwurfsmuster beschrieben ist,
wie kann man das konkret,
also konstruktiv umsetzen und dann auch noch möglicherweise konstruktiv in unterschiedlichen Programmiersprachen,
also objektorientierten Programmiersprachen umsetzen?
Weil das steht jetzt in dem Konstruktionsansatz zum Beispiel,
den ich jetzt gerade präsentiert habe für das Beobachtermuster.
Da steht jetzt Interface. Beobachter wird als Interface implementiert.
Dann sagen sie, oh, ich habe PC plus als Programmiersprache
, da gibt es überhaupt keine Interfaces.
Was mache ich denn jetzt
Na gut, das weiß jeder C-Plus-Blus-Programmierer weiß,
dann nehme ich halt, also abstrakte Klassen,
das macht keinen Unterschied, weil sie haben da mehrfach Vererbung,
während sie in Java bloß,
also jedenfalls das Implementation anbetrifft, einfach Vererbung haben.
Aber wie gehe ich denn mit der Frage um?
Also gibt sich durch die Möglichkeit der Mehrfachvererbung in der einen Sprache,
wäre es einfach Vererbung in der anderen Sprache,
geben sich da nicht aus andere Konstruktionsvarianten.
Wo man ja alles vielleicht also mal so aufgeblättert bekommt.
Wie setze ich das in Eifel um in Smalltalk,
in Java, in C-Plus plus in C-Sharps, ich sharp,
wäre auch nochmal ein interessanter was Informatiker halt so interessant finden.
Eine interessante Frage, weil also Sea Sharp hat im Gegensatz
zu Java eben auch noch sowas wie einen Ereignismechanismus.
Das kann ich also ganz anders anfangen, nicht ganz anders,
aber da habe ich eben erweiterte Möglichkeiten der Kommunikation zwischen Klassen.
So, und das will man eben wissen,
wenn es darum geht, also den Konstruktionsansatz zu beschreiben,
mit dem ein Entwurfsmuster realisiert werden kann.
Und das ist ja immer so beispielhaft, dargestellt.
Also das hier ist das Entwurfsmuster, um das mal in
einem Bild also zusammenzufassen. Und das, was wir hier,
was ich mit Ihnen jetzt gerade besprochen habe,
ist also der, ist der Konstruktionsansatz der Vererbung verwendet.
Also unser Überweiser erbt von beobachtbar, unsere Interaktion,
so implementiert das Interface, also auch eine Form von Vererbung, Beobachter.
Und anderer Ansatz ist also der Konstruktionsansatz über sogenannte Ereignisobjekte,
Event Objects
Ich habe ja vorhin, als ich grundsätzlich über Powling gesprochen habe,
gesagt, wir wollen mal diesen Powling-Ansatz effizienter machen.
Also erfinden wir den benachrichtigten Beobachter. Jetzt sagen,
verzeihen Sie, werde ich jetzt immer wieder auf Sie zurückkommen?
Also ich melde mich jetzt als Beobachter bei jemandem an.
Ich weiß aber eigentlich ganz genau von den 150 sondierenden Operationen,
also der jetzt zur Verfügung stellt.
Ich will eigentlich immer bloß, also zwei oder drei,
so einen ganz kleinen Ausschnitt der Schnittstelle,
will ich immer nur befragen.
Der Rest interessiert mich nicht
Ich kriege aber durch das einzelne Ping,
kriege ich gar nicht mit, ob sich etwas geändert hat,
das für mich relevant ist oder, also ob das irgendwas ist,
wo es eine hohe Wahrscheinlichkeit gibt,
weil er so von den 150 verschiedenen Möglichkeiten interessieren mich nur zwei oder drei.
Oder ob das etwas ist, was für mich völlig irrelevant ist.
Das kriege ich, also so viel Information steckt in einem einzelnen Ping einfach nicht drin. Da das offensichtlich also vielen Leuten so gegangen ist,
dass sie diesen prinzipiellen Lösungsansatz zwar toll fanden,
aber für ineffizient, also noch ineffektiv,
der war immer noch nicht effizient genug, so muss ich sagen,
haben die halt diesen Konstrukt Aktionsansatz der Ereignisobjekte,
der Event-Objects erfunden, der da heißt,
eine beobachtbare Komponente sagt eben nicht nur,
also ich bin beobachtbar und werde also meine Beobachter mit so Meldeänderungen oder beziehungsweise beachte Änderungen benachrichtigen,
sondern an meiner Schnittstelle stelle ich sogenannte Ereignisobjekte zur Verfügung.
Das heißt, ich kann für jedes einzelne Ereignis oder für
eine Gruppe von Ereignissen habe ich ein Ereignisobjekt,
bei dem sich Beobachter registrieren können.
Das ist also ein Punkt zu Punktverbindung zwischen einem Beobachter und
einem beobachtbaren Objekt
Gestellt wird. Also effizienter geht es nicht mehr,
was also diese Art von Synchronisation anbetrifft, bloß ist der konstruktive Aufwand,
um das herzustellen, ist also nochmal, also größer,
sodass also hier jeweils so eine Abwägung stattzufinden hat,
für dasselbe Entwurfsmuster unterschiedliche Konstruktionsansätze auch noch zu implementieren.
Ja, das ist jetzt ihr Problem, was sie daraus machen. Wir liefern ihnen ja hier,
das ist also die generelle Idee, also wir sagen ihnen,
also was man methodisch machen kann und wie das im Einzelfall dann angewendet wird, müssen sie im Rahmen ihrer Projekte, müssen sie das entscheiden. Wenn ich so gerade zum Anfang zurückkehren darf,
also so dieses, wenn sie dieses Creativity-Projekt machen,
dann können sie natürlich auch anfangen zu argumentieren,
wie sie bestimmte Sachen implementiert haben und da wollen sie nicht auf Klassenebene argumentieren,
sondern möglicherweise schon auf der Ebene von also eingesetzten Entwurfsmustern,
jetzt nicht nur da, sondern eben auch also woanders,
aber das ist auf jeden Fall,
ist auf jeden Fall eine gute Idee oder eine Idee,
die sich als tragfähig erwiesen hat, nämlich die Entwurfsmuster dazu zu verwenden,
um erstens also so existierende Softwareentwürfe,
also hier steht gleich zu analysieren, aber zunächst mal zu erläutern,
weil es macht eben einen Unterschied aus,
ob sie das so auf der Ebene von, ja,
dann habe ich jetzt die Klasse implementiert und die ruft dann die,
aber die erbt dann noch was von der und dann gibt es den Rückruf oder so,
das kann man ja machen,
statt also zu sagen,
die Oberfläche ist mit der Funktionalität über das Entwurfsmusterbeobachter
implementiert,
Alle Bescheid. Alle, die das Muster kennen und
dann hat man also so und so viele Tonnen,
also Informationen hat man also durch das Benennen des Entwurfsmus das übertragen.
Das ist doch schön. Und das gehören das so auf
der Ebene von der ganzen Reihe von Entwurfsproblemen machen kann.
Dann ist also die Analyse eines Programms einfacher,
wenn man so sagen kann, da steckt dieses Entwurfs,
musst du dahinter, aha, und da war das Problem der Firma.
Dieses Muster genommen, dann ist das also einfach eine sehr effiziente Art,
also ingenieursmäßig effiziente Art, also über Entwürfe zu sprechen und dann auch gegebenenfalls über eine Reorganisation von Implementationen, um diese Reorganisation zu planen. So,
Einarbeitung in Softwarearchitekturen Es ist, denke ich,
also es ist fast schon eine Selbstverständlichkeit, dass also,
wenn Sie gerade bei der Konstruktion Verwendung von Gui-Frameworks,
werden Sie das sehen, weil die massiv eben das,
also Beobachtermuster zum Beispiel verwenden,
wobei Beobachter würde man ja jetzt denken, das ist das Observer-Pattern,
also gucken, also dass das so ist,
aber in Java heißen die entsprechenden Klassen in Swingen,
das sind Listener, was also auch keinen Unterschied macht,
aber es ist eben so, das ist eben der Kanal,
der da angesprochen wird, sei es drum.
So, jetzt steht da,
sind Mikroarchitekturen,
das stimmt
Ja, wenn es nicht stimmen würde, hätte ich es nicht oder nicht,
mindestens glauben würde, hätte ich es auch nicht hingeschrieben.
Mikroarchitekturen deswegen, weil es eben immer nur Entwurfsmuster typischerweise so
eine kleine Anzahl von Klassen beschreiben, die dazu dienen,
ein bestimmtes kleines, überschaubares Problem zu lösen.
Sie werden also in späteren Semestern, werden sie noch über Makroarchitekturen,
also werden sie was hören, also wenn es darum geht,
wie organisieren wir ein System, das aus,
sagen wir, 10.000 bis 15.000 Klassen besteht.
Das kriegen sie nämlich auf der Ebene von Mikroarchitekturen auch nicht
mehr hin. Da gibt es auch keinen Entwurfsmuster für,
sondern dafür gibt es so Konzepte,
wie zum Beispiel Schichtenarchitekturen,
da reden wir dann später drüber
Stellen uns die Elemente einer Sprache, in der wir über Software-Architekturen nachdenken und kommunizieren können.
Ja, habe ich gerade gesagt. Also je mehr Muster
sie kennen, desto effizienter können sie sich darüber austauschen,
also was sie für gut und richtig für die Lösung von kleinen Entwurfsproblemen halten.
Und nicht zuletzt, also die Software-technische Qualität wird durch den Einsatz von Entwurfsmustern erhöht.
Ja, weil das sind ja dann sozusagen bewährte Praktiken,
nach denen man ein Problem löst und diese bewährten Praktiken haben eben den Charme.
Also sie können auch sagen, Andere haben das schon,
also nach Gamma muss ich für dieses Problem diese Lösung einsetzen
und sie brauchen gar nicht mehr viel argumentieren.
Sie können sich also an Standards orientieren und das hat also nicht automatisch,
aber doch gerade das erhöht, so denke ich,
nachvollziehbar, sowohl die Wiederverwendbarkeit als auch die Erweiterbarkeit,
um ganz zu schweigen von der Verständlichkeit ihrer Implementation.
So, 23 Entwurfsmuster haben GOF, wem sagt Also GOF
sagt ihnen wahrscheinlich nichts. Wem sagt Gang of 4 etwas
? Ja. Ja. Jetzt bin ich dem Kommilitonen,
der vor ihnen sitzt, schon persönlich zu nahe getreten.
Das dachte ich, trete ich ihnen jetzt auch noch zu nah?
Ich hätte erwartet, dass sie sagen,
das war eine Punkband in den 80ern
Die kenne ich nämlich noch von früher, to hell with poverty war der Mega-Hit. Ja, ist das, ja. So,
die Gang of 4, ja, das ist,
also, das sind Gamma-Helms, wie Cedis und Johnson,
das sind die, die die dieses Buch Design-Patterns geschrieben haben und die,
also kann man jetzt, also die kann man zitieren als GOF und jeder,
der Bescheid weiß, weiß dann auch, aha,
die sind gemeint und nicht, also die,
es gab da in China,
also irgendwann in den 80er Jahren gab es auch,
also die sogenannte Vierer-Bande, das war aber nicht so nett,
das war irgendwie Dieses Mal, die haben,
glaube ich, so ziemlich viel Unterdrückungsarbeit geleistet.
Also in dem Kontext, also ist diese Gang of Four nicht einzusortieren,
sondern die, diese Gang of Four, Gamma,
Helms, Johnson, Blic Seelest,
das sollten sie auch, also so diese vier Namen,
sollten sie dann auch irgendwann repetieren können.
Die haben halt insgesamt 23 Entwurfsmuster, klassifiziert, aufgeschrieben.
Also die vier Leute, ich weiß nicht,
vor allem die vielleicht so 100 Jahre Programmiererfahrung zusammengebracht und haben halt,
also hier sehen sie diese 23,
wo ist denn der Beobachter hier
Ja, ist er ja. Also der Beobachter ist ein
objektbasiertes Verhaltensmuster. Ich werde jetzt, also in den letzten
35 Minuten werde ich also nicht alle Entwurfsmuster hier durchgehen,
aber so sehen schon diese Entwurfsmuster, die kann man auch nochmal unterscheiden.
Also es gibt nicht einfangs so 23,
also Muster unterteilt von A bis K und von L bis Z,
sondern die sind auch nochmal unterteilt in, wozu sind die eigentlich gut?
Und dann gibt es eben nur,
um das hier mal so kurz zu sagen,
so was
wie Erzeugungsmuster
Die problematisieren, wenn nicht problematisieren, die liefern eine Lösung
für das Problem. Wie kann ich ein Objekt erzeugen?
Wenn Sie glauben, dass also, wo ist das Problem?
Das schreibe ich New irgendwas hin und dann habe ich
das Objekt. Ja, so kann man das machen.
Aber was machen Sie denn zum Beispiel, wenn also so
ein Objekt nur ein einziges Mal da sein soll?
Solche Objekte gibt es. Also sagen wir sowas,
zum Beispiel wie so eine Drucker-Cue oder so.
Das soll es halt nur einmal,
also so in so einem bestimmten Kontext gehen
Da soll nicht jeder eine neue Drucker-Cube machen können.
Und das ist ein wiederkehrendes Problem. So,
da haben die eine Lösung für. Das ist das Singleton
. Das ist jetzt so, das löst das Problem.
Wie schaffe ich es, dass ein Ding bloß einmal erzeugt werden darf?
Oder so die abstrakte Fabrik und die Fabrikmethode, so zwei Varianten, also derselben Geschichte.
Wie kriege ich das hin, dass ich ein Objekt erzeugt bekomme,
von dem ich eigentlich gar nicht wissen will,
von welcher Klasse es ist, sondern dass nur ein bestimmtes Verhalten zeigt.
So, ich will es gar nicht wissen, was das
für eins ist. Und ich will es nicht wissen,
weil also jede Kenntnis, das ist fast wie bei Geheimagenten,
Also jede Kenntnis von etwas macht mich,
genaue Kenntnis macht mich abhängiger von dem.
Also möchte ich davon abstrahieren. Ich möchte nur noch jemanden kennen,
der mir auf Anfrage ein Objekt gibt, das einer bestimmten Spezifikation genügt.
Dafür braucht man dann das Musterfabrik. So,
und wenn ich Ihnen das jetzt erzähle,
Sie sind ja noch, also vergleichsweise junge Menschen,
also da werden also Lösungen für Probleme,
werden da beschrieben,
von denen Sie vielleicht jetzt noch gar nicht wissen,
dass die existieren
Das ist, finde ich, also so sind ja Schleswig-Studierende an einer Universität.
Ich weiß nicht, wie oft sie das Gefühl haben,
dass wir ihnen Dinge erzählen, von denen sie gar nicht wussten,
dass sie sie nicht wissen wollen.
Also es gibt eben auch Probleme für Lösungen,
die sie noch gar nicht als Problem erkannt haben.
Aber wenn sie hier rauskommen, dann in zwei,
drei Jahren wissen sie, alles wird gut, Gamma at I,
haben für mich 23 Lösungen für von mir noch nicht entdeckte Probleme dahingeschrieben.
Und im Zweifelsfall kann ich da nachgucken. Also nicht,
dass sie jetzt glauben,
also dass da alle Probleme der Softwareentwicklung gelöst werden,
aber doch schon so ein paar wirklich gute Ideen sind da versammelt.
So,
ja, ja, das kann man alles
So, und jetzt sind diese 23,
also das ist jetzt hier nochmal beschrieben, so,
wozu, so wie diese insgesamt sechs Gruppen eigentlich,
also drei, also wenn man das aufgabenorientiert beschreibt,
wie diese drei Gruppen, also zusammenhängen.
Und sie können sich dann also das suchen,
irgendwann kennen sie die ja auch auswendig,
also jedenfalls die wichtigeren unter den Mustern.
Und sie sagen, aha,
ich brauche jetzt also mal hier einen Erzeugungsmuster,
dann kann ich also gleich in der richtigen Rubrik dieses Buches
nachschlagen.
So,
das ist der Klassiker
Englisch-Design-Patterns und jetzt kann man so erkennen, wer hat das Kammer,
Richard Halms, Ralph Johnson und John Flessie, das ist die Nachnamen,
die Vornamen kann ich mir auch nicht merken.
Und die deutsche Fassung davon, da hat ein ehemaliger Kommilitone von ihnen geschrieben,
ne, nicht geschrieben, also er hat das übersetzt,
der Grile, jetzt mittlerweile Professor Dr. Dirk Grile,
wo ist der jetzt gerade in Erlangen, ist der,
glaube ich, Professor für Open-Source-Software.
Also das ist sozusagen, also mit Einer ihrer Vorfahren hat also inhaltlichen Vorfahren.
Einer, der hier vielleicht auch schon gesessen hat,
hat, also dass die deutsche Fassung dieses Buches geschrieben,
so ein bisschen Ruhm über diese Tat fällt also auch bei Ihnen ab.
So, also jetzt,
gleich gibt es sowieso Regen ab in die Bibliothek,
das Buch holen und am Wochenende mindestens drei Entwurfsmuster sich zu
Gemüte führen und wir sehen uns irgendwann später wieder und
jetzt wünsche ich Ihnen noch einen schönen Tag.