Hi. Diese Woche geht es um den Wamm-Ansatz und ums Beobachtermuster.
Dazu wird es auch wieder zwei Videos geben. In dem
ersten stelle ich das Projekt kurz vor und teile die Klassen
des Projekts in die vier Elementtypen nach dem Wamm-Ansatz ein.
Und in einem zweiten Video geht es dann ums Beobachtermuster.
Das Projekt ist eine Bar und wir gucken uns jetzt einfach
mal die Klassen an, die wir da so haben.
Die erste Klasse ist Artikel. Hier steht unvorsichtigerweise
in dem Klassenkommentar Speisen und Getränke in der Bar.
Bei uns gibt es Gin
Die Artikel haben Namen, haben einen Preis vom Typ Integer,
die können hier im Konstruktor angelegt werden.
Es können Namen und den Preis, der kann zurückgegeben werden.
Und der Preis kann auch gesetzt werden.
Also die Klasse Artikel ist also ein Material nach dem Bamba-Ansatz,
weil Material nach dem Bamba-Ansatz ist ein veränderlicher,
fachlicher Gegenstand und veränderlich ist es ja zumindest durch diesen Setpreis,
der mit Werkzeugen bearbeitet wird.
Also nehmen wir jetzt einfach mal den Artikel und tun ihn
Zu den Materialien. Als nächstes haben wir eine Bestell-off-Lister-Werkzeug.
Das soll einfach die Bestellungen, die aufgenommen wurden pro Tisch
, anzeigen. Werkzeuge haben normalerweise was mit UI zu tun.
Das bekommt ja aber erst nächste oder übernächste Woche.
Deswegen geben wir das hier auf der Konsole aus.
Aber wie der Name Werkzeug schon sagt, gehört es eben in die Kategorie Werkzeuge.
Dann haben wir den Bestellservice Der dient dazu,
einfach Bestellungen aufzunehmen und sie in die Q zu packen.
Q ist ja first in, first out. Und man kann
eine Bestellung hinzufügen und man kann sich die Q mit allen Bestellungen ausgeben lassen.
Services stellen ja fachliche Dienstleistungen zur Verfügung. Und wie der
Name schon sagt, gehört das eben auch hier zum Element-Typ-Service.
Und dann packe ich das da auch mal rein.
Ignoriere das mal ganz kurz. Dann haben wir eine Bestellung,
eine Bestellung besteht aus einem Artikel und einer Menge dazu.
Das Ganze wird in einer Map abgelegt,
mehr Pashmap solltet ihr in SE1 gehabt haben, wenn nicht oder nicht genug,
dann gehen wir darauf nochmal in irgendeine Fragerunde oder so ein.
Und hier wird einfach immer für jeden Artikel die jeweilige Menge angegeben,
die pro Tisch, der wird hier übergeben, bestellt wurde.
Und eine Bestellung ist eben auch ein veränderlicher,
fachlicher Gegenstand, der mit einem Werkzeug bearbeitet wird.
Also kommt die Bestellung auch zu den Materialien
Die Rechnung, da werden einfach für sämtliche Artikel und Mengen,
die an einem Tisch bestellt wurden, wird eine Rechnung ausgegeben.
Da können erstmal Bestellungen hinzugefügt werden und dann kann eine Rechnung
erstellt werden und da gibt es hier auch noch,
dass man sich die Gesamtsumme ausgeben lassen kann.
Eine Rechnung ist eben auch genau wie ein Artikel zum Beispiel
ein Material, also tun wir es halt auch an
die Stelle
Eine Speisekarte, die kennt natürlich auch jeder. Das sind
einfach sämtliche Artikel, die in der Bar gelistet sind.
Da kann man Artikel hinzufügen, Artikel entfernen.
Man kann sich nach dem Namen Artikel raussuchen lassen.
Man kann sich alle Artikel rausgeben lassen und man kann auch
gucken, ob so ein Artikel gelistet ist.
Man kann entweder nach dem Artikel, das ist ja eine Objektreferenz,
gucken oder auch nach dem Namen.
Und eine Speisekarte ist dann in dem Sinne halt auch
ein Material
Und wir packen es dahin. Start-up startet wie immer das Programm.
Und wir legen hier in der Klasse auch die Artikel an.
Wir haben hier ein paar Gin-Sorten mit dem jeweiligen Preis.
Der Preis bei dem Artikel hatten wir ja gesehen,
ist ein Int. Also geben wir das hier ein.
Wir haben eine Tischnummer. Und hier werden erstmal Artikel zur Speisekarte
hinzugefügt. Dann wird eine Bestellung simuliert. Und dann passieren
damit Dinge, die wir uns dann später noch angucken.
Das gehört nicht wirklich zu irgendeinem Elementtyp.
Also lassen wir es,
wo es ist
Und dann haben wir als letztes noch Tisch.
Tisch ist ein unveränderlicher, fachlicher Gegenstand,
weil der hat eine Tischnummer, die so bleibt.
Der steht immer am gleichen Platz, wie er angeschraubt.
Man kann die Tischnummer zwar drucken, aber hier ist nichts,
womit man diesen Tisch verändern könnte.
Und unveränderliche, fachliche Gegenstände sind Fachwerte. Und deswegen packen
wir diesen Tisch hier in die Kategorie Fachwert.
So, und jetzt ist einiges rot geworden oder auch nicht.
Gucken wir mal, sieht eigentlich im Moment
noch gut aus.
Das ist da drin
Das ist da drin, er hat offensichtlich die Objektreferenzen gleich sauber mitverschoben.
Jetzt würde ich mir ein Material nochmal ansehen,
gerne mit euch, und zwar hier den Artikel,
der hat ja einen Preis und der ist vom Typ Integer.
Da kann man sich natürlich überlegen,
ob der Typ Integer hier sinnvoll ist,
weil man kann ja eine Menge Rechnungen dann auf den Preis anstellen,
die nicht wirklich sinnvoll sind.
Also man könnte ja auch einfach, wenn es vom Typ Integer ist,
zwei Preise miteinander multiplizieren und das ergibt jetzt nicht so wahnsinnig viel Sinn,
weil es einfach nun mal keine Quadrateururo gibt.
Also wäre es ja irgendwie ganz gut,
wenn wir was hätten, was fachlich zum Preis
besser abbilden kann
Und das ist dann halt etwas, was in die Kategorie Fachwert
gehört und da würde ich mir mit euch jetzt mal die Klasse Geldbetrag schreiben.
So eine Klasse definiert ja eine Wertemenge und die Operationen,
die auf der Wertemenge möglich sind. Und wenn wir dann in durch Geldbetrag ersetzen,
das ist das Gute an Fachwerten, können wir die Operationen,
die auf dem Preis möglich sind, auf das beschränken,
was wirklich sinnvoll ist und wir können auch den Wertebereich darauf beschränken,
was sinnvoll ist,
weil es wird auch keine negativen Preise geben.
Also machen wir uns hier gleich in der Kategorie Fachwert
Eine neue Klasse. Und die nennen wir Geldbetrag.
Genau. Und die kriegt erstmal ein Feld.
So ein Typ Intager. Und das ist der Euro-Anteil.
Und das Gleiche machen wir. Mit dem Cent-Anteil.
So, im Konstruktor bekommt das Ding einen Intager übergeben.
Ein Indiger übergeben, den nennen wir Cent-Betrag.
Nein, mit einem Tee. Und den können wir uns
dann aufteilen auf Euro-Anteil- und Cent-Anteil. Der Euro-Anteil ist
nichts anderes als der Cent-Betrag, der da eingegeben wurde.
Geteilt durch 100. Interger Division, alles was nach dem Komma
ist,
wird weggeworfen und dem Cent-Anteil
Ja. Holen wir uns eben,
indem wir Modulo von dem Cent betragen, bilden,
also den Rest einer ganz zahligen Division,
und zwar Modulo, 1100. Und dann fangen wir an,
uns die Operationen oder Methoden zu definieren, die fachlich sinnvoll sind.
Dieses erste ist Public, gibt einen Geldbetrag zurück.
Und heißt Adire. Und da können wir
zwei Geldbeträge rein
Immer noch nicht. So Mant. Eins und der zweite
Geldbetrag ist so Mann zwei. Jetzt sehe ich auch,
ach ja, das ist vom Typ Geldbetrag logischerweise.
Jetzt sehe ich auch, warum das mit dem Geldbetrag nicht geklappt hat,
weil ich immer wieder zwei Buchstaben vertauscht habe.
Geld wie Tag. Warum meckert er hier? Ach,
ich habe es hier oben natürlich auch. Deswegen hat er
den Konstrukt und nicht als Konstrukt er erkannt und schon ist alles gut.
Okay, und jetzt machen wir uns eine Summe,
die ist vom Typ Int.
Und da nehmen wir
den ersten Sumanten
Und sagen, Geld, Cent, Betrag. Und holen uns
vom zweiten so mannten. Auch Geldgeldbetrag. Centbetrag. Und
dann returnen wir Einen neuen Geldbetrag. Und zwar mit der Summe. Jetzt ist es so,
dass hier ein D fehlt, jetzt ist es so,
dass er gezählt Centbetrag noch nicht kennt,
wir kennen das alte Spiel, Steuerung 1,
dann bietet er uns an, Treate Method,
das finden wir gut, das wollen wir haben,
wir wollen auch in Innen rausgeben und deswegen brauchen wir
nicht,
wir returnen gleich
Den Euro-Anteil mal 100 plus den Cent-Anteil.
Das sind ja, das ist ja unser Geldbetrag hier incent.
Dann machen wir uns noch eine zweite Methode.
Adiere. Die nimmt nur einen Geldbetrag entgegen
Schon immer wieder so Mant. Und die Return.
Ah, wir bilden erst wieder eine Summe.
Also in Summe. Gleich. Dezentbetrag. Das holt jetzt
den Centbetrag von einem Objekt dieser Klasse.
Und addieren dazu den Centbetrag von dem Sumanten.
Gezentbetrag, genau.
Und wir returten wieder
Einen neuen Geldbetrag. Mit der Summe. Okay,
jetzt könnten wir das Ganze auch noch mit einer Zahl multiplizieren.
Ich würde mich hier auf eine ganze Zahl beschränken.
Es kommt wieder ein Geldbetrag dabei raus.
Und es ist ein Faktor vom Typ Int,
der da übergeben wird, Und es wird ein Produkt gebildet.
Das ist so ein Typ in, das habe ich natürlich mal wieder vergessen.
Und das ist Good Cent Betrag mal im Faktor.
Und wir returnten wieder
neuen Geldbetrag
Mit dem Produkt im Konstruktor. Dann können wir uns
natürlich auch noch den Euro-Anteil und den Cent-Anteil zurückgeben lassen,
also Public Int, Get Euro-Anteil.
Und das returnt schlecht. Den Euro-Anteil. Das Gleiche machen
wir mit dem Cent-Anteil auch
Und Kat. Cent. Anteil. Keine Parametern. Und
alles Return-Wert. Den Cent-Anteil. Und jetzt könnten wir uns
ja unseren Geldbetrag auch gerne schick mal ausgeben lassen wollen.
Also machen wir uns eine Methode. Public. Die gibt
einen String zurück. Und die heißt Get for Matthia
Ten Geldbetrag
Und diese Methode returned. Den Cent, den Euro-Anteil.
Dann konkortinieren wir daran noch so ein Komma.
Und damit verknüpfen wir dann, gib vor, naja,
schreibt mich halt Get for mal Tierten
Cent. Anteil. Das ist eine Kolon.
Natürlich haben wir diese Methode noch nicht gebaut. Steuerung 1
, Create Method. Wir wollen hier einen String zurückgeben.
Das To-Do wollen wir ja nicht. Und zwar,
wenn der Cent-Anteil, kleiner Zähnes,
das ist so das gleiche Spiel wie mit der Uhrenanzeige aus SE1,
dann wollen wir was returnen und zwar Wollen wir eine Null davor schreiben?
Und dann den Cent-Anteil verknüpfen. Und wenn es eben größer
gleich zehn ist, dann können wir gleich den Cent-Anteil returnen.
Ja, genau. Damit wir daraus einen String machen können,
müssen wir es natürlich mit einem leeren String verknüpfen,
weil ansonsten würden wir versuchen,
ein Int bei Rückgabetyp String zurückzugeben.
Okay, das ist unsere klasse Geldbetrag,
die ist fachlich auf die Operationen beschränkt,
die wir tatsächlich hier auch für unseren, für unser Projekt brauchen,
aus irgendeinem Grund schimpft er noch mit uns.
Ah, okay, das Pfeil heißt auch noch falsch,
Refactor, Rename. Also wenn ich schon falsch schreibe,
dann konsequent überall. Okay, jetzt ist alles gut.
Auch wie gesagt, auf die Operationen beschränkt,
die wir für unser Projekt brauchen
Ist hier unsere Klasse Geldbetrag. Jetzt wollen wir das Ganze
noch auch tatsächlich benutzen. Also rufe ich Artikel offen,
was ich dann ganz gerne mache,
wenn ich nicht suchen will, wo überall das auftaucht.
Nämlich einfach die Exemplarvariable. Macht daraus einen Geldbetrag und guckt
dann, wo er überall meckert. Zum Beispiel hier,
hier wird ein Int reingegeben. Das soll aber dann
Geldbetrag sein. Dann meckert er hier bei der Vorbedingung,
weil sie ja jetzt nicht mehr so ein größer Gleichrelationen hat,
sondern ein Ungleichnall
Und dann gucken wir mal weiter. Hier wird der Preis rausgegeben,
das soll ein Geldbetrag sein und kein Int mehr.
Hier kommt ein Int rein, da soll ein Geldbetrag rein.
Und hier müssen wir dann wieder die Vorbedingungsprüfung dahingehend ändern,
dass wir auf ungleichen Knall prüfen.
Und das sollte es eigentlich für diese Klasse hier gewesen sein.
Jetzt meckert die Rechnung ein bisschen rum,
aber das kriegen wir auch in den Griff.
Genau. Gebt Preis, hier haben wir Preis mal Menge
Artikel gepreist, ist ja schon ein Geldbetrag und dafür haben
wir ja eine ganz wundervolle Methode, die heißt multipliziere.
Irgendwo steht sie auch,
nehmen wir die und multipliziert wird eben mit der Menge,
also packe ich das hier hinten auch so dran.
Genau, und es wird kein Int mehr rausgegeben, sondern Geldbetrag.
Und dann haben wir hier noch was, und zwar eine Summe,
hier wird auch kein Int mehr rausgegeben, sondern Geldbetrag.
Die Summe ist dann logischerweise vom Typ Geldbetrag wird initialisiert mit einem neuen Objekt.
Der klasse Geldbetrag. Im Übergehen dann null.
Und hier können wir jetzt einfach unsere Methode addiere nehmen.
Und schieben das alles da rein,
weil wir ja zu dem Geldbetrag, den wir hier haben,
den Geldbetrag, den wir uns hier rausgeholt haben, addieren wollen.
Dann sieht das da auch gut aus.
Wir speichern und sehen, alles ist prima.
Jetzt haben wir
noch hier
unsere klasse Startup
Da habe ich, weil ich jetzt hier nicht alles nochmal
mit einem Geldbetrag tippen wollte, einfach schon mal einen auskommentierten Block.
Dementsprechend nehmen wir das hier einfach raus, weil das hier
ist ja mit Int und kommentieren den Kram hier ein, Steuerungsshift 7.
Schon ist es einkommentiert. Und er meckert mit uns,
weil er will gelb Betrag importieren, alles gut.
Er will Tisch auch importieren
Weiß man es nicht, ja. Oben machen. Okay,
ich habe irgendwie den Tisch mitgelöscht. Also muss ich jetzt
hier mal mit einigermaßen viel Steuerung Z das wieder zurückmachen,
lösche das hier raus, lass den Tisch, wo er ist.
Kommentiert das wieder ein. Importiert den Geldbetrag wieder.
Dann ist hier alles gut, mal speichern und dann funktioniert
die Klasse auch. Das war das erste Video,
das ist so ein bisschen das Projekt vorgestellt und im zweiten
Video geht es dann mit dem Projekt weiter und es geht
dann um das Beobachtermuster.
Also bis dann