Hey, wir sind zurück mit den Werttypen.
Ich hatte euch ja versprochen, dass wir aus unserer Klasse
Geldbetracht so einen echten Werttyp machen, was das ist.
Das sehen wir gleich. Aber erstmal zeige ich euch
ein paar Veränderungen im Code, eigentlich kleine Veränderungen.
Erstmal habe ich einen Klasse-Geldbetrag neu geschrieben, die ganz genauso aussieht wie Geldbetrag.
Ich habe einfach nur unsere Methoden, ist multiplizieren möglich,
jetzt hier in einem Third auch tatsächlich verwendet.
Also das ist hier in Vorbedingungen
Und das Gleiche habe ich mit addieren möglich gemacht.
Das heißt, wir haben hier,
Ed Require ist addieren möglich und hier wird die Vorbedingung überprüft,
ganz brav mit Kommentar und so weiter und so fort.
Jetzt haben wir hier oben ja einen Konstruktor, der zwei Euro,
also einen Euro-Anteil und einen Cent-Anteil entgegennimmt, also zwei End.
Und wir wollen jetzt erst mal mit sowas ähnlichem wie,
ist Adire möglich, dafür sorgen,
dass hier nur gültige Werte reinkommen?
Also schreiben wir uns jetzt hier
eine Methode,
Ist gültiger Euro-Anteil. Und da kommt ein Int rein,
den nennen wir eure Anteile.
Und da überprüfen wir einfach, können wir gleich return schreiben.
Null kleine Gleich-Euro-Anteil
Das heißt, wir wollen keine negativen Geldbeträge haben und Euro-Anteil.
Kleiner 100. Das heißt, wir wollen nur bis 99 Cent gehen.
Ach ja, wir sollten hier vielleicht ein Rückgabetyp angeben.
Und dann funktioniert das Ganze unseres Ähnliches. Machen wir jetzt
auch Mit dem Cent-Anteil. Es gibt Gulien zurück. Ist
gültiger. Cent-Anteil. Nimmt einen Int entgegen, den wir
Cent-Anteil nennen. So, was wollen wir da überprüfen?
Hier oben habe ich natürlich Quatsch geschrieben. Es muss nicht
kleiner als ein 100 sein. Es ergibt wirklich wirklich null Sinn,
sondern es muss kleiner, gleich integer.max Value sein.
Aber hier unten schreiben wir sowas. Hier Return wäre wieder ein Null.
Kleiner, gleich. Cent-Anteil. Und jetzt sagen wir,
der Center-Anteil kann ja tatsächlich nicht 100 werden.
Cent-Anteil. Kleiner, 100. Und dann haben wir einen goeting
So, jetzt ein bisschen zu den Werttypen,
als ich SE2 gehört habe und es dann auf einmal hieß,
bei den Fachwerten, Fachwerte sind was ganz Besonderes,
Fachwerte werden nicht erschaffen, Fachwerte waren schon immer da,
also da war irgendwie so das Beispiel mit der zwei,
die zwei hat es schon immer gegeben,
die zwei wird nicht erst, die zwei wird nicht erschaffen,
die zwei wird aus dem Universum der Zahlen ausgewählt,
selektiert, da habe ich auch gedacht, ja Leute,
Teil von dem, was er mir erzählt,
ich will die Wertemenge einschränken können,
zum Beispiel auf Euro nicht unter null.
Ich möchte die Operationen, die auf dieser Wertemenge möglich sind, einschränken.
Das nehme ich euch voll ab. Das ist richtig gut.
Aber der Geldbetrag wird nicht geschaffen, sondern er wird selektiert,
weil er Geldbetrag irgendwie schon immer da war.
Das hörte sich für mich schon ganz extrem nach Wammesoterik an.
Ist es aber nicht. Es hat tatsächlich einen ganz praktischen
Nutzen, den ich euch gleich noch zeigen werde
Und deswegen bauen wir uns das Ganze jetzt mal so um,
dass wir nicht tatsächlich hier einen neuen Geldbetrag von außen erzeugen können.
Und das kriegen wir hin, indem wir einfach die Konstruktoren private machen.
So. Okay, wie kommen wir denn jetzt an unseren Geldbetrag,
wenn wir von außen auf die Konstruktoren nicht zugreifen können?
Wir bauen uns einen tatsächlichen Selektor. Das ist jetzt ein Begriff,
den gibt es nicht in Java,
sondern es ist einfach was, was die Leute,
die mit dem WAM-Ansatz zu tun hatten,
so genannt haben,
der muss natürlich
öffentlich sein
Ästhetik. Es war klein. Das heißt,
er soll auf der Klasse aufrufen werden können.
Heißt Select. Nimm zwei Int entgegen.
Nämlich einen Euro-Anteil.
Und einen Cent-Anteil
So, ein Rückgabetyp brauchen wir natürlich auch und zwar Geldbetrag.
Neu, das Neue kommt einfach nur daher,
weil ich diese Klasse von unserer alten Geldbetragklasse unterscheiden können wollte.
Okay, was machen wir denn jetzt? Dieses,
so ein Geldbetrag wird nicht erschaffen, sondern ausgewählt, bedeutet,
dass wir ja eigentlich irgendwie so eine Wertemenge schon bräuchten.
Und die machen wir uns jetzt tatsächlich und zwar mithilfe
von der Hashmap.
Private Map
Ihr wisst ja, so ein Mapper hat ein Key und ein Value.
Key ist vom Typ String. Unser Value ist vom Typ Geldbetrag
. Neu. Das Ganze nennen wir tatsächlich auch Wertemenge.
Und wir machen es hier gleich inline,
weil wir ja keine von außen zugreifbaren Konstruktoren mehr haben.
Gleich ein New Hashmap. Ich gebe die Elementtypen mal
ganz gerne trotzdem noch an.
Also String. Geld
Ertrag. Neu. Klau auf Klammert zu, Semi Colan.
Map und Hashmap müssen wir importieren. So,
da können wir ja jetzt irgendwie unsere Geldbeträgereien packen.
Wir bauen uns also zuerst ein Key, also ein String,
den wir als Key dafür verwenden können.
Also lokale Variable vom Typ String, nennen wir vielleicht auch
gleich Key
Und der ist, der muss ja eindeutig sein,
das ist unser Euro-Anteil. Plus, also wir konkatinieren,
jetzt haben wir daraus auch tatsächlich einen String gemacht.
Immer wenn man was mit dem String-Con katiniert,
kommt ja ein String dabei raus.
Plus tatsächlich ein String, also ein Komma, plus Cent-Anteil,
Semikolon, dann passt das.
Jetzt haben wir uns unseren Key gebaut.
Und jetzt sagen wir das folgende.
Wertemenge. Ach ja, unsere Map muss auch Static sein,
sonst können wir nicht darauf zugreifen.
Aus einer statischen Methode. Punkt. Und jetzt Contains Key
steht auch gleich da. Dann nehmen wir unseren Key.
Eigentlich wollen wir das machen, wenn es nicht den Key enthält.
Also machen wir einen Not davor. Und dann machen wir
das hier. Dann erzeugen wir uns. Das ist natürlich
jetzt ein böses Wort. Wir erzeugen es nicht wirklich.
Wir machen uns einen neuen Geldbetrag und fügen es
unserer Wertemenge hinzu
Unter Strich. Wertemenge.pot heißt das bei Maps.
Da kommt unser Key rein und jetzt New Geldbetrag neu.
Und da müssen wir jetzt unseren Euro-Anteil übergeben und unseren Center im Teil.
Also wenn wir hier was reinkriegen und wir stellen fest,
Das ist noch nicht in unserer Wertemenge hier enthalten.
Dann erzeugen, in Anführungsstrichen,
wir uns das Ding und packt es in die Wertemenge rein.
Und wir returnen hier Wertemenge. Punkt. Get. Und
da packen wir unseren Key rein. Und das wird returnt.
Also das ganze Ding hat auch tatsächlich draußen in der freien Natur,
hätte ich jetzt fast gesagt,
in der freien Wirtschaft nahmen das Ganze nennt sich Factory Pattern,
das ist eins von den Entwurfsmustern, die es gibt.
Was wir hier machen, ist nichts anderes als wenn wir
hier einen Geldbetrag haben wollen, bestehend aus eurem Anteil und Cent-Anteil.
Gucken wir, ob wir den schon mal gemacht haben.
Wenn wir den noch nicht gemacht haben, das heißt,
wir haben ihn noch nicht in der Map drin,
packen wir in die Map, in die Map rein.
Wenn nicht, wissen wir ja eher Star und in jedem
Fall geben wir dann den entsprechenden Value zu diesem Key aus
der Map raus
Das hat folgenden Vorteil. Dadurch,
dass jeder Geldbetrag jetzt tatsächlich nur ein einziges Mal existiert.
Und aus dem Universum der Geldbeträge selektiert wird.
Weil diese Zeile hier wird ja nur dann aufgerufen,
wenn wir ihn noch nicht hatten. Ist es tatsächlich so,
dass wir zwei Geldbeträge jetzt mit gleichgleich vergleichen können.
Wir müssen nicht mehr Punkt Equels nehmen und die Equels-Methode überschreiben,
sondern wir können jetzt gleichgleich nehmen.
Das heißt, wir haben dann tatsächlich einen Werttypen gemacht
wie Int oder Float.
Die kann man ja
sofort mit gleichgleich vergleichen
Und das können wir jetzt hier mit unserem Geldbetrag auch machen,
ohne kompliziert erst mal unsere Equals-Methode überschreiben zu müssen.
Weil normalerweise, wenn man einen zwei Referenztypen miteinander vergleicht,
wird ein Referenzvergleich durchgeführt, mit gleich gleich.
Und dann wird geguckt, ob beide Referenzvariablen auf einen und
dasselbe Objekt zeigen. Da hier aber das Objekt nur ein
einziges Mal existieren kann, bedeutet diese Referenzgleichheit auch gleichzeitig inhaltsgleichheit.
Es hörte sich jetzt ein bisschen komisch an
Ist es aber gar nicht wirklich. Deswegen habe ich
hier nochmal diese Methode Start-up gebaut. Diese klasse Start-up,
haben wir wieder die Main-Methode drin. Und hier haben wir
von unseren normalen Geldbetrag, Betrag 1 und Betrag 2,
die sind inhaltsgleich, die kriegen 1 Euro, 20 Cent.
Und dann lassen wir uns hier mal ausgeben, was passiert,
wenn wir Betrag 1 und Betrag 2 mit Gleichgleich vergleichen.
Jetzt nehmen wir unseren neuen Geldbetrag. Machen da auch zwei Referenzvariablen,
betrat 9-1, Betrag 9-2 und selektieren
hier einen Geldbetrag mit einem Euro und 20 Cent.
Und dann gucken wir mal, was dabei rauskommt,
wenn man das mit gleich, gleich vergleicht.
Und ich hoffe, das klappt jetzt. Mal gucken.
Also Run as Java Application. Und da steht's. Geldbetrag,
Vergleich mit gleich gleich. Er gibt False. Weil hier
dieser Referenzvergleich auf Referenzvariablen zeigt, die auf unterschiedliche Objekte zeigen.
Hier gibt der Vergleich mit gleich gleich True,
weil diese beiden Referenz war Java,
tatsächlich auf ein und dasselbe Objekt zeigen,
weil durch dieses Select ist das Objekt tatsächlich sowohl diesen zugewiesen worden als auch dieser Referenz Variablen zugewiesen.
Und deswegen ist diese Wam-Esoterik vielleicht gar nicht mal
so sehr esoterisch, sondern hat tatsächlich was Sinnvolles.
So, das war es jetzt von mir für diese Woche
und wir sehen uns dann einfach nächste Woche wieder.
Bis dann