reicht wehmütiger Stimmung bin. Das, was ich gerade so
dachte, als ich darauf schaute, Vorlesung 11 im SE2.
Das heißt, zweimal sehen wir uns noch und dann nicht mehr.
Jedenfalls nicht im Rahmen von SE2. Ja, wir sind also,
wir sind, wenn man mal so einen mindestens 13 Vorlesungen pro Semester, oder sind es 14?
Führung, es sind 14, oder halb bis 14,
12. Ah, ich bin nicht wieder mit meinem Plus-Minus-1-Problem.
Okay, also noch zweimal werden wir noch wach und dann ist Schicht im Schacht.
Heute geht es um Werte und Objekte in Programmiersprachen.
Wir werden uns das mal anschauen, warum man das unterscheidet,
warum wir das für sinnvoll halten, das zu unterscheiden.
Das ist ja begrenzt, begrenzt lustig, in objektorientierten Programmiersprachen,
über Werte nachzudenken oder zu versuchen, Werte als eigenes Konstrukt zu implementieren.
Sie sind mit Werten, schon so ein Kleider der Idee,
die ich heute hier ausbreiten werde,
sind Sie schon ein klein bisschen nahe gekommen in der Diskussion über so diese Flammen-Modellarchitektur,
diese Architekturblaupause, weil da gibt es ja so ein Konzept namens Fachwerte.
Und was das ist, warum wir das tun,
das wird heute ausgebreitet, in gewohnter Manier.
Ich rede eine Dreiviertelstunde darüber, was da so konzeptionell,
was wir uns konzeptionell da überlegt haben und die zweite Dreiviertelstunde wird Fred den einen oder anderen Wert implementieren.
Gut, nächste Woche Und das auch nochmal,
also den Zusammenhang herzustellen, so eigentlich hätten sie erwarten können,
dass ich heute an der Stelle weitermache,
wo ich letzte Woche aufgehört habe, da die Übung aber verlangt,
dass sie viel über Fachwerte wissen,
also schiebe ich heute diesen oder machen wir heute diesen Teil und greifen also die Folien von der letzten Woche in der nächsten Woche wieder auf.
Wir haben ja noch zwei Vorlesungen lang Zeit. So,
Motivation, Programmieren ist modellieren, wir haben darüber gesprochen
Und das, was wir tun, wenn wir Software entwickeln,
ist, wir bauen Modelle. Ja, wenn wir modellieren,
bauen wir Modelle und wir modellieren einen Ausschnitt der Welt.
Als ich diesen Satz gelesen habe, stand da noch ein Ausschnitt
der Wirklichkeit der Wahrheit und da stand noch was mit Realität.
Also das sind so philosophisch mehrfach, sind bedeutungsschwere Begriffe.
Die habe ich jetzt erstmal alle rausgenommen. Also das existiert so,
wir gehen jetzt mal von der Annahme aus,
die ist, glaube ich, haltbar,
so für den Alltag,
für den alltäglichen Umgang,
da draußen existiert
Eine Welt und wir wollen Menschen in ihrer Arbeit,
in dieser Welt unterstützen und dazu bauen wir Modelle, diese Modelle laufen.
Diese Modelle sind ablauffähig und wir beschäftigen uns ja mit nichts anderem als,
nichts anderes ist jetzt auch übertrieben,
aber womit wir uns bei der Programmierung im Wesentlichen beschäftigen,
ist die Modelle so zu gestalten,
dass Menschen in ihrer täglichen Arbeit durch diese Modelle unterstützt werden.
Also Aufgaben, Erledigungen einfacher fällt in der Art und Weise,
wie wir sie oder durch unsere Unterstützung mit Software.
Also jetzt schauen Sie sich das da an Äh.
Und was sie da sehen, ist ein Software-Werkzeug und
dieses Software-Werkzeug ist in einer Organisation eingesetzt worden.
Dies, die gibt es möglicherweise noch,
aber die hat heutzutage eine etwas anderen Aufgabenzuschnitt.
Das ist das Bundesamt für den Zivildienst. Ich glaube,
ich habe schon an anderer Stelle mal gefragt,
meine Herren, wer von ihnen hat gedient?
Tja, so viele sind das ja nicht mehr.
Und wer hat Zivildienst gemacht
Das sind mehr, ach so, ja, hier, ich auch, ja.
Also wir alle, die jetzt gerade die Hand gehoben haben,
werden von dieser Organisation noch verwaltet. Und was sie da sehen,
ist, das ist eins der Werkzeuge,
mit denen die da umgehen und das Material, das dort bearbeitet wird,
ist die ZDL-Akte, der Zivildienst, die Zivildienstleistenden Akte.
So, da werfen wir jetzt gleich noch einen Blick drauf,
so eine der Sachen, die man da lernt,
wenn man sich mit Zivildienstleistenden oder überhaupt mit der Arbeit in dieser Behörde beschäftigt ist,
also dass so ein Zivildienstleistender kann also unterschiedliche Zustände einnehmen, je nachdem,
also so wie diese Behörde da drauf schaut, also sie können bedienstunfähig sein.
Sie können eingezogen sein, sie können Fahnenflüchtig sein,
so in unterschiedlichen Zuständen kann man unterschiedliche Dinge mit ihnen tun.
Und das, was ich gelernt habe,
das habe ich jedenfalls im Hinterkopf behalten,
ist also die höchste Form der Dienst-Unfähigkeit ist der Tod.
Wenn Sie tot sind, das bedeutet für die Behörde,
man kann sie nicht mehr einberufen. Das ist so.
Das wäre ein Fehler, wenn das passieren würde. Das darf nicht passieren, das wollen wir nicht. Und wenn wir da jetzt noch so weitere Blicke drauf werfen,
Auf dieses Werkzeug, das die da verwenden, denen sie,
man muss unglaublich viele Sachen über sie wissen, um,
also sie anständig verwalten zu können und so ein paar von den Werten,
mit denen dort umgegangen wird, ist also so das Quartal,
in dem sie einberufen werden, weil viele Berechnungen sind quartalsabhängig,
wann, also hier sind also verschiedene Formen von Daten,
Zeiträumen, ich habe versucht mich zu erinnern,
wofür ZDP steht,
das ist mir nicht wieder eingefallen,
musste es
nochmal nachgucken
Also das ist aber etwas ganz Häufiges, dass es solche,
dass es irgendwelche Werte gibt, die offensichtlich einer bestimmten Syntax genügen.
Also ist das hier, ob das eine Null oder ein O ist,
sei mal dahingestellt. Jedenfalls kommt dann so ein Schrägstrich,
dann kommt eine Ziffernfolge mit einer offensichtlich immer gleichen Anzahl von Ziffern.
Und dahinter weiß man nicht, Bindestrich und an sowas.
Jetzt hat Fred hat mit ihnen schon über reguläre Ausdrücke gesprochen. Das heißt,
man könnte jetzt mit diesem mittelreguläre Ausdrücke, könnte man wahrscheinlich auch überprüfen,
ob ein bestimmter Wert der da eingegeben wird, zum Beispiel an der Oberfläche,
ob der einer bestimmten Syntags genügt. So, und die Frage,
die ich jetzt erstmal so in den Raum werfe, ist,
na, wenn Sie das da jetzt programmieren sollten, so,
dass etwas sowas wie in der Art, also Daten,
Quartale, Zeiträume, wenn so was an der Oberfläche eingegeben werden soll,
was haben Sie da zur Verfügung, um das Zeug,
in Anführungsstrichen, später zu verarbeiten.
Und die naheliegendste Idee,
die mir so direkt in den Kopf kommt, naja gut,
das sind doch, also das sind offensichtlich,
sind das Zeichenketten und das
sind Strings
Strings, ja, das hat man den Java,
kriegt man ja freie Haus als Datentypen und ich modelliere das
jetzt einfach mal, Softwareentwicklung ist modellieren.
Ich modelliere jetzt diese Daten alle als Strinks. Dann ist es mindestens mal,
was die eigentliche Verarbeitung anbetrifft, ist das okay.
Das kann ich ja machen. Wenn man jetzt also nur Strings verwenden würde,
würde das also auch, würde es also möglich sein,
an der Oberfläche, was ist denn mal so ein signifikantes Datum hier?
Schade, kommt kein, doch hier, das ist ein signifikantes Datum. So,
dann wenn sie einen String an der Oberfläche akzeptieren würden als Eingabe,
könnt ihr ja einen Witzbold, wir arbeiten keine Witzbolde,
aber da könnte doch, obwohl das ist im Rheinland,
also so diese Rheinischen Fonatouren in Köln ist das Bundesamt,
die könnten auf die Idee kommen,
an der Stelle jetzt einfach mal hinzuschreiben, Silvester
2005. Das ist ja auch ein String, oder?
Warum auch nicht? Oder dann schreiben sie einfach Karneval,
Karnevalsanfang. Also so irgendwas, ein String jedenfalls,
das ist nicht der 31.12.12., aber ist im Rheinland auch ein signifikantes Datum.
Das wäre syntaktisch gesehen, wäre das okay.
Für die spätere Verarbeitung ist es eine Katastrophe,
also ein Datum erwartet wird und da steht Silvester.
Weil das ist kein, also entspricht nicht diesem Format.
Und die Frage, der wir jetzt im Weiteren nachgehen,
ist, so wollen wir das erlauben?
Nein, wollen wir nicht. Und wenn wir das nicht erlauben,
welches Mittel steht uns eigentlich,
stehen uns Mittel zur Verfügung, diese fachlich motivierten Werte,
also wie zum Beispiel ein Datum, auch adäquat zu modellieren,
um dann in der weiteren Verarbeitung im Programm auch damit umzugehen.
Jetzt sehen Sie mal noch so ein paar Beispiele,
also Zeitraum haben wir schon genannt,
so ein paar weitere Beispiele für fachliche Werte
Für Werte, die wir so im Anwendungsbereich finden.
Also wenn ich jetzt sage, wir finden die,
dann bitte ich sie jetzt mal so vor ihrem geistigen Auge,
sowas wie eine Brille aufzusetzen. Also so eine Wertorientierte Brille,
an welchen, eine Brille die Werte entdecken kann.
Und dann schauen Sie mal da drauf, so das,
was Sie da so sehen, ob das jetzt Zeitpunkt,
Geldbetrag, Sie sehen ja die Erläuterungen jeweils dahinter.
Das sind ja, so wir nähern uns ja dem Thema,
das sind so Dinge in anderen Anführungsstrichen,
die in erster Linie so einen Wertcharakter haben.
Das hier, finde ich, besonders schön.
Da hat jemand versucht, also sich politisch korrekt auszudrücken,
wenn ein neuer Mitbürger, also Baby, eine Sozialversicherungsnummer bekommt,
so die wird nicht erzeugt.
Also das Baby wird erzeugt. Nee, das heißt,
glaube ich, geht, zeugt, nochmal was anderes.
Und dieses Baby bekommt dann eine gültige Sozialversicherungsnummer zugeordnet.
So keine Ahnung, wie die Syntax dieser Nummer aussieht,
das ist jedenfalls,
ist das
so ungefähr Sonnenoschi
Und die Idee ist jetzt, also wir gucken mit dieser
Brille Werte, wo gibt es Werte? Also Dinge,
die eine bestimmte Syntax haben, wo gibt es die,
wo verwenden wir die? Und die Frage ist jetzt,
die nächste Frage, welche Mittel stehen uns zur Verfügung?
Softwareentwicklung ist Modellierung, das in einer Objektorientierten Programmiersprache auszudrücken.
Und wir werden sehen, also die Möglichkeiten dazu sind,
begrenzt, jedenfalls zurzeit noch. Das ändert sich gerade,
komme ich später auch noch zu. Wir müssen gucken,
dass wir das, was wir anwendungsfachlich als Wert identifiziert haben,
auch adäquat in einem objektorientierten Programm modellieren.
Was kriegen wir hin
Weil, was haben wir denn in so einer Programmiersprache wie Java,
was haben wir da zur Verfügung als Werttypen?
Zunächst mal sind das so alles,
was so mit Zahlen zusammenhängt, ist also quasi natürlich,
also wird das auch als Wert in einer Programmiersprache wie Java, wird das umgesetzt.
So, und die Frage, die da steht,
sind das Objekte, die lässt sich, glaube ich,
also da steht jetzt keine Antwort ja oder nein,
aber so das, was da so als Erläuterung gegeben wird,
denke ich, ist schon,
ist das ziemlich nachvollziehbar.
Die vier ist kein Objekt
Welcher Umgang mit Objekten wird Ihnen, wenn das ein Objekt wäre,
wie würde man denn damit umzugehen haben?
Muss ich der Zahl 4 jetzt an der Zahl 4 die
Operation plus aufrufen und ihr als Parameter eine 3 übergeben?
Und es gibt objektorientierte Programmiersprachen, in denen muss ich das
genau so ausdrücken. Da komme ich gleich auch noch zu.
Smalltalk ist es. Hervorragendste Beispiel dafür, aber irgendwie,
also ich will nicht behaupten, dass das unnatürlich ist.
Es ist auf jeden Fall ungewohnt,
weil wir aus der Schule, Schulmathematik sind wir einen
anderen Umgang mit Zahlen
Einen anderen Umgang mit Zahlen gewöhnt. Two oder False,
also so werden solche Objekte, wird das erzeugt?
Nee, eigentlich nicht, oder? Also ich möchte mit Werten,
möchte ich eigentlich einen anderen für sie je spezifischen Umgang haben und den möchte ich auch entsprechend implementieren.
In der handelsüblichen objektorientierten Programmiersprache ist das nur möglich für die sogenannten primitiven Typen.
Gleichzeitig gibt es da draußen in der Welt, also die,
die wir mit unserer Software Glücken wollen, in Anführungsstrichen.
Also gibt es einen tradierten, einen unfassbar lange Tradition,
jedenfalls im Verglangen im Vergleich zu dem,
was die Informatik zu bieten hat, gibt es einen Umgang mit Werten.
Also Sie sehen da so als Beispiele, die Naturwissenschaften oder alles,
was mit Technik zu tun hat. Also da gibt es,
da gibt es lange Erfahrungen, so lang ganz,
also nicht nur lange, sondern auch tiefe Erfahrungen,
also mit so einem Konzept wie Werten umzugehen und wir in der Softwaretechnik haben das also nur,
in der Softwareentwicklung haben das bis jetzt,
also gerade in der Beschäftigung mit Objektorientierten Programmiersprachen,
haben wir das, sagen wir mal, etwas vernachlässigt,
um es milder auszudrücken.
Wir können das, wir können das noch nicht entsprechend ausdrücken.
Wir wissen uns also in der,
wenn wir diese Anwendungsfachlichen Konzepte, Werte modellieren wollen,
müssen wir uns also mit Hilfskonstrukten zunächst mal die Zeit,
bis das also auch in den Programmiersprachen ausgedrückt werden kann,
müssen wir diese Zeit ein klein wenig überbrücken.
Jetzt setzen wir wieder, wir setzen weiterhin diese,
wir wollen Fachwerte entdecken,
Brille auf und wir entdecken mal
Solche weiteren Fachwerte. Sie sehen hier so als signifikante Beispiele, Postleitzahl, Bankleitzahl.
Wenn Sie sowas implementieren wollen, was liegt da nah?
Also Strings habe ich schon genannt als Implementierung.
Aber gerade sowas wie Postleitzahl oder Bankleitzahl oder Kontonummer,
da könnte man ja auch einen Intager für nehmen, oder?
Wir sind ja schließlich Zahlen. Dass diese Zahlen eine,
dass die eine spezielle Syntax haben, sei mal dahingestellt.
So bei Strings könnte man wieder die regulären Ausdrücke nehmen,
um das zu überprüfen.
Aber bleiben wir mal bei einer Realisierung als Intager
Sie können dann, wenn sie, also eine, sagen wir mal,
eine Postleitzahl als Intet, nehmen wir lieber den Geldbetrag.
Wenn sie den als Integer realisieren, dann können sie,
mit dem die Sachen machen oder die Operationen durchführen,
die mit Integern halt zulässig sind.
Also addieren, subtrahieren, das sind für Geldbeträge,
so wie es da steht, sind es ja auch nachvollziehbare
Operationen.
Aber Geldbeträge werden nicht miteinander multipliziert
Das tut man einfach nicht. Also nicht aus moralischen Gründen
oder so, das ist aus anderen Gründen.
Aber das ist keine Umgangsform mit Geldbeträgen. So syntaktisch wäre
das aber, wenn man einen Geldbetrag als Intager implementiert,
wäre das möglich. Und sie können sich sicher sein,
wenn also eine Variable nur Geldbetrag heißt, sie aber vom Typ Intager ist,
irgendjemand wird auf die Idee kommen, das zu multiplizieren.
Und das ist nicht etwas, das ist etwas,
was sie nicht zulassen wollen, als jemand,
der ein Stück Software modelliert und sagt,
dass es ein Geldbetrag und mit einem Geldbetrag soll nur das gemacht werden können,
was man mit Geldbeträgen macht, nämlich addieren und subtrahieren.
So, das will ich ausschließen. Und das,
ich habe ja schon an anderer Stelle mal gesagt, ich möchte Ihren,
meinen, unseren Gestaltungsspielraum möchte ich an bestimmten Stellen auch einschränken.
Und das ist jetzt wieder so ein Fall. Ich möchte,
dass wir, wenn jetzt, bleibt mal bei Geldbeträgen,
wenn wir Geldbeträge modellieren und die haben so einen Wertcharakter,
sollen mit diesen Geldbeträgen nur das getan werden können, was fachlich auch sinnvoll ist.
Und das wiederum bedeutet, ich muss im eigenen Werttypen implementieren,
um dieses Verhalten zu realisieren. Das ist etwas,
was Fred dann auch im Dava mal umsetzen wird.
Aber das werde ich jetzt mal noch ein klein wenig motivieren.
Erstmal so, wenn sie diese Brille der Fachwerte aufsetzen,
müssen wir uns noch so ein etwas besseres Verständnis.
Was macht eigentlich den Unterschied zwischen Werten und Objekten aus?
Diesen Unterschied müssen wir uns noch mal an verschiedenen Beispielen versuchen, klar zu werden,
weil so wie ich das bis jetzt motiviert habe oder das,
was ich bis jetzt so an Beispielen genannt habe,
scheint es vergleichsweise klare Unterscheidung zu sein,
in vielen Anwendungsfällen kommen gleich dazu, muss man noch etwas genauer hingucken,
ob man etwas als Wert oder als Objekt verstehen möchte,
beziehungsweise dann auch modellieren, schrägstrich implementieren möchte.
Und zu dieser Reise lade ich sie jetzt mal ein.
Werte sind abstrakt. Sie sind immer so
eine Abstraktion von etwas
Also sie sehen hier diese Beispiele. Das ist ja fast so Sesamstraßenniveau
. So was soll das denn jetzt hier eigentlich symbolisieren?
Was soll das, was soll das modellieren? Nun,
diese Werte sind, wie es da steht,
immateriell und sie sind eine Abstraktion von etwas.
Das gibt es ja da draußen in der Welt.
Also wenn ich jetzt sage, das gibt es eigentlich nicht.
Also ich will mich hier nicht auf erkenntnistheoretisches, sehr glattes Eis bewegen.
Da kenne ich mich überhaupt nicht aus. Also alles,
was mit so Wahrheit, Wirklichkeit, Realität zu tun hat,
so für uns hier, für den Hausgebrauch der Softwareentwicklung,
So können wir uns, glaube ich, darauf zurückziehen.
Da würde ich mich schon wieder halbwegs sichern. Also wenn ich das hier sehe,
dann sind das halt zwei Maiskolben und die Abstraktionen,
die hier stattfindet, ist, also wenn ich das Zeug zählen will,
dann ist es ganz hübsch.
Also wenn ich die Zahl 2 als Wert in meinem Sprachgebrauch zur Verfügung habe,
ich dann abstrahiere ich halt in dem Moment davon,
ob das jetzt hier zwei Kirschen, zwei,
was immer das hier sein soll oder zwei Maiskolben sind.
Das ist ganz hilfreich, um darüber sprechen zu können.
Diese Zahl 2,
die ist da
Die brauche ich nicht zu erzeugen, die brauche ich nicht,
also die kann auch nicht zerstört werden.
Das ist so eine charakteristische Eigenschaft von Werten. Demgegenüber können Objekte
erzeugt und zerstört werden. Das heißt also, die Objekte,
die haben einen Anfang und ein Ende und ich mag eigentlich
diese Art von Animation nicht, aber die ist so unglaublich gut gelungen.
Ruhe in Frieden, dieses Objekt B hat eine Lebenszeit.
Das Leben dieses Objektes fängt irgendwann an und dann kann ich anfangen,
darüber zu sprechen und nicht nur das.
Ich kann an diesem Objekt, also in dem Moment,
wo es angefangen hat zu leben, kann es,
also können dort die Operationen aufgerufen werden.
Und wenn das zerstört worden ist,
dann kann ich also da keine Operationen mehr dran aufrufen.
Ich weiß nicht so wirklich, was also damit gemeint ist,
wenn da steht, aus Sicht eines Objektes sind drei Zeitabschnitte relevant,
vor Erzeugung während seiner Lebenszeit und nach seiner Zerstörung.
Und ich würde mich eigentlich darauf so beschränken wollen,
erstens weiß ein Objekt nichts darüber, was für es selbst interessant ist,
sondern das, was für uns als Entwickler interessant ist,
Ab dem Moment, ab dem es erzeugt worden ist,
kann ich was damit machen und danach nicht mehr.
Das ist also Objekte sind ja auch nur Menschen. In diesem Sinne,
also da unterscheiden sie sich aber von Werten,
weil Werte, das ist jetzt auch immer im Gegensatz,
so wird das jetzt hier kontrastiv gegenübergestellt,
Werte kann ich nicht erzeugen und deswegen brauche ich sie auch nicht so zerstören und ich kann also,
wenn ich über diese Werte in meiner Programmiersprache verfüge,
kann ich ständig alle daran aufrufbaren Operationen ausführen
Im Unterschied zu Objekten. Welche sehen Sie es nochmal?
Werte sind zeitlos? Ich brauche diese, ich brauche sie
nicht zu erzeugen. Das ist also das Symbol für die
Unendlichkeit. Sie sind immer da. In dem Kontext,
also gibt es Sprachpuristen, konservative Menschen.
Es sollte sich nicht bewerten, schneide das mal raus.
Bitte, was ich da jetzt gerade gesagt habe,
die also aufgerollte Fußnägel kriegen,
wenn Menschen in ihrem Alter zum Beispiel
über zeitnäher sprechen
Kannst du das bitte zeitnah erledigen? Weiß jeder von uns,
was gemeint ist, aber man kann bei Zeit nicht von Nähe sprechen.
Das ist, die Begriffe, Zeit und Dauer sind nicht anwendbar bei Werten.
Weil sie sind immer da. Insofern kann man auch nicht
von Zeit Nähe sprechen. Eben genauso in diesem Zusammenhang,
das finde ich das auch sehr schön gesagt,
also Werte werden nicht verbraucht.
Weil sie halt immer da sind
Okay, Objekt, potenziell veränderbar. Ja, Objekte befinden
sich in einem Zustand und dieser Zustand kann verändert werden.
Tja, bis es dann halt endgültig kaputt ist,
ist ja wie Software, wenn die nicht gewahrt wird,
gewartet wird, dann erodiert sie langsam.
Software ist ja auch unsere, wie Autos. So,
die Identität, das ist der wichtige Punkt an der Stelle,
die Identität, man kann also bei Objekten,
die haben eine Identität,
demgegenüber Werte haben keiner Identität
Auf dieses Objekt zeigen und sagen, das ist mein Auto.
Ich kann aber nicht auf eine 2 zeigen und sagen,
das ist meine 2. Oder das ist deine 2.
Und die 2 ist ja einfach da.
Also sie hat keine Identität, weil sie einen Wert ist.
So, weiter geht's. Werte sind unveränderlich. Wenn ich
auf die 40 eine 2 addiere,
dann verändere ich nicht die 40 zu einer 42,
sondern ich erzeuge einen neuen Wert.
Nur einen anderen Wert. Werte kann man nicht erzeugen,
sondern das Resultat dieser Operation ist dann
die Zahl
Und da jetzt so drüber nachzudenken,
so wie ich das gerade schon gesagt habe,
ich schicke an die Zahl 40 die Nachricht plus und ich übergebe
den Parameter 2 und es kommt ein Objekt namens 42 dabei raus,
ist konsistent.
Ich kann das so machen, ob ich das so machen will,
ist eine andere Frage. Und das ist jetzt so die Randbedingung,
wenn ich sage Softwareentwicklung ist Modellierung, wie ganz am Anfang.
Also man kann solche Modelle in sich schlüssig,
kann man diese Modelle sehr weit treiben
Eine andere Frage, ist es dann,
wie weit entspricht das der Art und Weise,
wie ich über einen Anwendungsbereich in diesem Fall rechnen,
inwieweit entspricht das so der Art und Weise,
wie ich sonst über diesen Anwendungsbereich nachdenke?
Die vorläufige Antwort ist eher nicht. So,
den Punkt hatte ich schon genannt. Objekte sind zustandsbehaftet.
So Objekte können dann insbesondere auch ihren Zustand verändern.
Werte können das nicht. Der Wert an solcher ist zustandslos.
Der Wert Das hat einen Wert und Operationen mitwerten können,
also neue Werte hervorbringen, aber den Zustand eines Wertes kann da überhaupt,
also das zu sagen, fällt schon schwer,
dass sich der Zustand eines Wertes so verändern kann.
Das ist also so im Alltag,
wenn sie jetzt gerade mal wieder ihre Brille aufsetzen,
wenn sie sagen, ich bin umgezogen,
ich habe eine neue Adresse.
Was bedeutet das dann? Oder ich habe,
meine Adresse hat sich verändert,
sagen wir es lieber so
Verstehen Sie ja, was ich meine.
Meine Adresse hat sich verändert. Nee, hat sie nicht
. Sie haben eine neue Adresse. Das ist, weil
die Adresse als Wert modelliert, kann sich nicht verändern.
Sie kriegen jetzt eine neue Adresse. Und das sind so
die Stellen, wo ich von denen nicht gerade gesprochen habe.
Also wann wollen Sie etwas als Wert modellieren und wann als ein,
also als unveränderlichen Wert modellieren und wann wollen Sie etwas modellieren
als einen Zustandsbehaftetes,
sich veränderndes Objekt
Wenn das macht nochmal, das kommen wir ja so in
diese verschiedenen Punkte, die man da jetzt diskutieren,
dann gehen wir jetzt mal so eine nach dem anderen durch.
So, weil bei Objekten kann ich also auch die Frage
unterscheiden, also ist das das gleiche Objekt?
Oder ist das dasselbe Objekt, von dem wir jetzt hier gerade sprechen?
Und das ist im alltäglichen Sprachgebrauch, geht es ja munter durcheinander.
Und es stört aber auch keinen, weil wir wissen,
in der Regel, also wovon wir sprechen,
was wir meinen, und man kann das also mindestens durch Rückfrage,
kann man das auch klären, Wir haben aber auch schon erfahren,
dass es also einen bedeutsamen in der objektorientierten Programmierung, einen bedeutsamen Unterschied macht.
Ob es also, ob wir die Frage nach Gleichheit stellen,
zwischen zwei Objekten oder ob wir die Frage nach der Identität eines Objektes stellen.
Und das ist, ich habe ja schon so gesagt,
also wir wollen hier nicht ins Philosophische, ins Philosophische abdriften.
Aber das hier sollte man sich auch klar machen,
ein Objekt kann sich zu einer Zeit immer nur an einem
Ort,
in einem Raum befinden
Das ist bei Werten, ist es,
ist das ziemlich belanglos, sich darüber Gedanken zu machen,
wo das Ding ist oder wann das Ding ist.
Bei Objekten, so macht es einen Unterschied.
Und das hat also ganz schön viele Konsequenzen,
gerade für die Entwicklung von sogenannten verteilten Software-Systemen.
Wenn Sie also eine Objektorientierte Programmiersprache verwenden und Objekte modellieren,
die ein Konzept der Welt da draußen, also vergegenständlichen,
dann müssen Sie,
ob Sie das wollen oder nicht,
sich auch darüber Gedanken machen
Wo ist dieses Objekt, das Sie modellieren jetzt gerade?
Kann ich da von verschiedenen Stellen gleichzeitig drauf zugreifen und
welche Konsequenzen hat das, wenn Sie das erlauben?
Und das sind so Fragen der Verteilung von Software,
die hier dann zum Tragen kommen.
Und je weniger gedanken Sie sich darüber bei der Modellierung schrägstrich Programmierung machen,
desto schwieriger wird es für diejenigen, die die Software benutzen,
ein nachvollziehbares Benutzungsmodell zu identifizieren.
Da wird es auch noch Da macht diese Unterscheidung auch
noch mal, kriegt diese Unterscheidung eine Bedeutung. So,
das haben wir jetzt soweit, haben wir uns das erschlossen.
Werte abstrakt, zeitlos, unveränderlich versus Objekte sind zustandsbehaftet,
können verändert werden und sie haben eine Lebensdauer. Sie sind,
sie müssen von jemandem erzeugt und auch dann müssen nicht,
aber sie werden in der Regel auch von jemandem zerstört.
Und wenn es dann der Garbage Collector ist,
der für uns
diese Aufgabe übernimmt
So, jetzt, also habe ich hoffentlich halbwegs nachvollziehbar argumentiert,
dass es sinnvoll ist,
sich mit der Unterscheidung zwischen Werten und Objekten zu beschäftigen.
Und wir entdecken solche Werte und Objekte im Anwendungsbereich und jetzt
wollen wir das Ganze in Objektorientierten Programmiersprachen.
Das sind die Programmiersprachen unserer Wahl.
Wollen wir diese Konzepte auch möglichst unmittelbar implementieren können?
Bei Objekten gelingt uns das schon ganz gut.
Die Frage ist, wie kriegen wir das jetzt für
die Werte hin
Was haben wir für Konzepte? In Java, und das ist,
sagen wir mal, als Vertreter der typischen objektorientierten Programmiersprachen,
mit denen wir es zu tun haben.
Also gibt es also diese Werttypen, die Sie da sehen? Und das ist so,
das ist sozusagen das ganze Bouquet, das uns zur Verfügung steht,
das ist weit entfernt von Kontonummern, Postleitzahlen, Geldbeträgen.
Das lässt sich zwar alles damit realisieren, ist aber nicht das,
woraus es den genannten Gründen Ist aber nicht das,
worauf wir hinaus wollen. Das hier ist so eine gewisse,
der Purismus ist so eine Vermutung, die wir,
so diese Folien hier zeigen, mal so in den Raum stellen.
Wie gesagt, also da ist Bewegung in der Landschaft und
es wird eine Java-Sprachversion in nicht allzu ferner Zukunft geben,
in der sogenannte Value Objects realisiert werden können.
Und das geht schon ziemlich, das geht mindestens in die Richtung,
in die ich hier auch argumentiere,
dass also Fachwerte ein Sprachbestandteil,
Sprachbestandteil werden
Ich war schon kurz darauf eingegangen, dass in einer Sprache,
die sie im Rahmen ihres Studiums möglicherweise noch kennenlernen werden,
je nachdem, in welche Richtung sie sich spezialisieren,
die sich noch kennenlernen werden, haben Smalltalk.
Das ist eine sehr puristische,
objektorientierte Programmiersprache und das ist ein wirklich berühmtes Zitat,
also jedenfalls unter Softwareentwicklern, dass die Smalltalk 80 des Smalltalk 80 programmier Handbuch,
so ein Buch, Das fängt mit dem Satz an,
der da steht, every sing is unobject.
Nach dem, was ich jetzt gesagt habe,
so über Objekte versus Werte, man sagt, naja,
das ist schon eine sehr spezielle Sichtweise, die da eingenommen wird.
Und das ist eben genau in der Programmiersprache Smalltalk,
muss man dann eben, weil eben die Zahlen auch Objekte sind,
in der von mir gerade beschriebenen Art, so mit Zahlen umgehen.
Okay, es gibt noch andere objektorientierte Programmiersprachen,
in denen das also vergleichbar,
je nachdem, also wie man die Vergleichsoperation implementiert,
also liefert das jetzt tue,
was ich sage,
in denen dieses Konzept
vergleichbar umgesetzt worden ist
So, und es gibt aber, hat sie das sich mal anschauen,
was so sich so in den, so seit,
sagt man so, über Sprachen der dritten Generationen spricht,
was sich da so an Programmiersprachen entwickelt hat.
Also die Welt ist da bunt und vielfältig bei denjenigen,
die Programmiersprachen, die Programmiersprachen entwickeln.
Und wir haben hier auf der Seite der funktionalen Sprachen,
also wo ausschließlich wertorientiert, modelliert wird und auf der Seite
der objektorientierten Programmiersprachen Hört sich da auch einiges getan.
So was in der letzten Zeit zu beobachten ist, ist,
dass diese zwei Welten auch wieder ein klein wenig zusammenwachsen.
Das hat vor allem damit zu tun, dass so Applikationen geschrieben werden,
die in denen massiv parallel Verarbeitung ermöglicht werden soll.
Und das lässt sich mit wertorientierten Programmiersprachen mit funktionalen Programmiersprachen
sehr viel einfacher realisieren, als mit objektorientierten Programmiersprachen.
Das heißt, aus der Notwendigkeit heraus Parallelisierbarkeit zu ermöglichen,
werden also jetzt, Projektorientierte Programmiersprachen um funktionale Konzepte erweitert,
um wertorientierte Konzepte erweitert, weil die andere Formen effizientere Formen,
vor allem parallelisierbare Formen der Verarbeitung zulassen.
In diesem Sinne ist also die Beschäftigung mit Werttypen,
also nicht nur ein Anwendungsfachlich, motiviertes Unterfangen, sondern auch,
also was die eigentliche Verarbeitung von Softwaresystemen anbetrifft,
so kann das damit motiviert werden.
Also wir werden im Rahmen von SE2 werden wir nicht mehr auf,
also die Kombination von Objektorientierung und Funktionalen Konzepten eingehen,
aber sie werden in fortgeschritteneren Lehrveranstaltungen, werden sie sich auf diesem Thema noch widmen können.
So, wir sind also, auch die jetzige,
so die Entwicklung der Programmiersprache Java geht auch, also in die Richtung,
dass also funktionale Elemente wertorientierte Elemente in die Sprache integriert werden.
Jetzt bin ich mit meinen konzeptionellen Überlegungen schon
fast am Ende
Ich wollte eigentlich nur noch einen Punkt hier erwähnen.
Das sind diese, das sind die sogenannten Werttypen. Das,
worauf wir mit diesem Werttypen eigentlich, nicht eigentlich,
aber so im Großen und Ganzen hinausrollen ist,
dass die Fachwerte eine Erweiterung der Basismaschine darstellen.
Die Basismaschine, sie haben uns auf der einen Folie gesehen,
das sind Integers, Buliens.
Also alles, was sie so an Werttypen haben.
Und wir wollen die Basismaschine um fachlich motivierte Typen erweitern
Also in den Programmen, in denen sie, die sie nachher modellieren,
dass sie also möglichst schnell wegkommen von der Ebene.
Ich habe es hier mit einem String oder mit einem Intager zu tun und das,
womit sie zu tun haben wollen, in der Verarbeitung ist,
dass sie so schnell wie möglich von der Oberfläche hin zu fachlich motivierten Werttypen kommen.
Weil diese Art der Modellierung, Softwareentwicklung ist Modellierung,
also ist unter anderem mit der Folge verbunden,
dass die Fehler in der Verarbeitung so früh wie möglich entdecken können.
Wenn jetzt also, wir kommen wieder auf die Datumseingabe zurück,
wenn sie einen Werttyp-Datum in ihrem Programm verwenden können, dann können sie sicher sein,
dass nirgendwo nirgendwo mehr so peinlich auffällt, fehlerhaft auffällt, dass da jemand Silvester eingegeben hat.
Nur weil dieses Datum, also ein String-Typ gewesen ist,
wenn sie einen Datumstyp haben, dann wissen sie,
dass sozusagen ein Millimeter hinter der Glasoberfläche, jetzt,
dass ich darauf verlassen,
dass ein Wert vom Typ Datum immer ein korrektes Datum enthält und nicht erst fünf Verarbeitungsschritte weiter in der Datenbank oder wenn die Datenbank also in einer anderen Form ausgewertet wird,
dass erst sehr viel später in der Verarbeitung auffällt,
dass das kein korrekt eingegebenes Datum ist,
eben weil der zugrunde gelegte Datentyp, also nicht dein Datum war,
sondern nur in Anführungsstrichen ein String.
So, und damit sind wir an der Stelle,
wo es jetzt darum geht,
dass sich auch mal die Konstruktion von Werttypen in einer Programmiersprache für Java anzuschauen,
die das also von Hause aus eigentlich nicht mitbringt,
nicht mitbringt,
dass man genau diese Art von Umgang mit Werttypen,
dass man den in seinem Programm auch pflegt.
So, Fred, up to you. Und wir sehen
uns dann nächste Woche wieder und dann ist Schluss.
Wie lustig. Danke. Gut, ich wollte mit euch
mal einen einfachen Werttyp bauen
Dafür machen wir uns mal ein neues Projekt.
Nennen wir das doch mal Bruchrechnen vielleicht.
Ich hoffe, ihr überherrscht noch die Regeln der Bruchrechnung.
Dann machen wir uns mal einen neuen, eine neue Klasse.
Und ich würde jetzt gerne natürlich sagen können,
das soll keine Objektklasse sein, sondern eine Wertklasse,
die so Unterscheidungen gibt es aber in Java noch nicht.
Ich nenne die mal, wir programmieren immer gerne auf Englisch,
Rational. Also Rational heißt so viel wie ein Bruch.
Eine Ratio, ein Verhältnis A im Verhältnis zu BEA
durch B.
Das ist ein Bruch
So, das ist die eigentliche Klasse. Und bevor wir jetzt anfangen,
die zu implementieren, würde ich eigentlich ganz gerne mal so,
dass wir uns Gedanken machen,
wie man die eigentlich benutzen will von außen.
Und dafür eigen sich ja Testklassen immer sehr toll.
Mit immer rational Test. Ein vernünftiger Test. Ja,
das soll ja alles hinzugefügt werden. So. Okay.
Guido hat ja ein paar Folien einfach aus Zeitgründen übersprungen.
Es gibt also auf den Folien auch noch so ein Kochrezept für euch.
Wie kann ich eigentlich eigene Wehrtypen in Java bauen?
Und da ist zum Beispiel eine Sache,
dass man nicht dieses New verwenden will.
Dass ich also nicht sowas schreibe wie rational
A, gleich New Rashional und dann irgendwie 3,4, nach dem Motto 3 Viertel.
Dieses New will man normalerweise nicht sehen bei der Benutzung von solchen Werttypen,
weil es eben so aussieht, als würde man etwas erzeugen.
Technisch tut man das mal natürlich. Aber man will halt von dieser Idee weg,
dass man Werte erzeugt und man will eigentlich so einen Wert,
ja, selektieren, der schon da ist.
Also wenn es jetzt ein Entwehr, machen wir die Zahlung
nochmal kurz weg. Also wenn das Ganze entwehr,
dann könntet ihr zum Beispiel schreiben, A, gleich 3. Ja,
also man sagt nicht irgendwie New 3 oder so,
sondern man schreibt einfach den Wert so hin,
wie man ihn haben will und man hat nicht den Eindruck,
dass da irgendwas erzeugt wird.
Und sowas ähnliches wollen wir eben
auch haben
Okay. Ja, was könnte man eine Dame für eine Sonntags nehmen?
Wir könnten eine statische Methode einfach aufrufen auf dieser Klasse.
Wir können sagen, zum Beispiel Rational, sagen wir mal,
Value-Off, das ist so eine Standardkonvention in Java.
Es gibt ganz viele Typen in Java, haben so eine Methode Value-Off.
Ich höre mal zum Beispiel Strings, ja,
ihr könnt sozusagen string.value-off, 42 zum Beispiel, ja.
Das würde euch ein String liefern,
wo eben die Ziffern 4 und 2 drin sind. Ja,
oder wenn ihr es andersrum haben wollt,
wenn ihr sagt, ich habe ein String,
wo eine Zahl drin ist und ich will daraus wieder eine Zahl machen,
dann könnt ihr sagen,
intx ist gleich Intager,
Machen wir es mal ein bisschen direkter. Ja, also
das ist so eine Konvention in Java. Wenn du irgendwie,
ja, einen Wert auswählen willst, dann nimm diese Value-Off-Methode.
Ich kürze sie auch manchmal ab, dass ich nur oft sage,
aber wir halten uns mal in die Konvention, ne?
Das würde ich also gerne die klassische so benutzen können,
dass ich dieses Value-Off auch rufen kann.
Okay. Dann will man vielleicht auch an die einzelnen Bestandteile
rankommen. Ja, wie wollen wir denn da rankommen?
Also irgendwie sowas wie A. Numa Rator heißt,
glaube ich, Zähler, oder?
Ich glaube, ich gucke das mal ganz kurz nach.
Nicht,
dass wir jetzt hier Unsinn programmieren
Zähler, Englisch. Ich hoffe, dass da was Vernünftiges mal rauskommt.
Oh, habe ich kein Internet. Ah, ich habe
kein Internet. Dann wird es natürlich nicht funktionieren.
Dann machen wir uns mal kurz Internet. So,
mal gucken, was der rotierende Kreis mir gleich verrät,
ob es funktioniert oder nicht.
Das sieht auch gut aus. Also noch neuer Versuch.
Was heißt Zähler auf Englisch? So, hat er
sich gemerkt
Ah ja, Nummer Raiter, das stimmt. Dann gucken
wir gleich einen Nenner, das ist ein komplizierteres Wort.
Die Nummer Raiter oder so, kann das sein?
Die Nominator. Okay. Kein neuer Film mit Arnold Schwarzenegger
. Von die Nominator. Gut. Ja,
Jay Unit, haben wir lange nicht benutzt, oder?
Also, es hört Equals, da müsste eine 3 zurückkommen.
Und hier müsste eine 4 zurückkommen. So. Okay,
das ist natürlich alles noch nicht übersetzbar
Wir müssten das jetzt mal anfangen zu bauen,
damit dieser eine Test, dieser erste Test mal zumindest durchläuft.
Gut. Kann ich ja eigentlich direkt Eclipse sagen,
dass er das für mich machen soll.
Womit fangen wir mal an? Fangen wir mit vielleicht mit
dem Value auf an. Sag ich mal, generiere doch mal
diese Methode für mich. Hier ist sie. Okay,
dann gehen wir mit dem mal vielleicht mal einen sinnvolleren Namen,
nennen wir das mal einen Numerator und die Normin Lato.
So, machen wir hier mal ein bisschen mehr Bild.
Okay, ja. Vorschläge von eurer Seite,
was ich da
jetzt machen kann
Also intern müssen wir sicherlich irgendwie Objekte erzeugen, oder?
Ja. Okay, also nach dem Motto Exemplar variablen Anlegen.
So. Und du würdest das jetzt wahrscheinlich gerne da reintun,
ne? Das wird, glaube ich, nicht funktionieren.
Weil wir hier in einer statischen Methode drin sind.
Die wird ja nicht auf einem Objekt dieser Klasse aufgerufen
Also ich will nicht, dass man von außen dieses New aufrufen kann.
Aber irgendwie muss ich das ja intern wahrscheinlich machen.
Ich muss mir ja irgendwie behelfsmäßig solche Objekte erzeugen.
Ich meine, Vorschlag, wie ich dafür sorgen kann,
dass ich zwar das New benutzen kann,
aber nur innerhalb dieser Klasse.
Ja. Genau, mit dem privaten Konzept dann.
Sehr gut. Wir machen uns einen privaten Konstruktor,
der kriegt hier dieselben Parameter.
Und dann können wir die Zuweisung mal vielleicht davon nehmen.
So. Ich habe es
Das ist also der ganz normale Konstruktor, den ihr so kennt,
aber man kann ihn jetzt von außen nicht benutzen,
weil ich will nicht, dass er ein Klient New sagt,
weil das halt gegen dieses Konzept verstößt von Werttypen.
Okay, und was kann ich jetzt in dieser öffentlichen Methode machen?
So geschummelt quasi halb, ja. Genau, ups,
jetzt habe ich ein B. Okay. Jetzt kann man sich
darüber streiten, lohnt sich dieser ganze Aufwand? Der Witz ist halt,
ihr könntet später, wenn ihr fortgeschrittenere Java-Programmierer seid,
könnt ihr dir dafür sorgen,
dass in dieser Methode zum Beispiel, ja,
Rational Objekte rausgeliefert werden,
die ihr vorher schon in irgendeinem Cash oder Pool oder so abgelegt habt.
Das geht über die Inhalte von SE1,
SE2 hinaus
Aber das könnte man machen. Ah, nee,
ich glaube, es ist sogar eine Zusatzaufgabethema auf dem aktuellen Blatt.
Also ihr könnt schon mal so ein bisschen in die Richtung gucken,
möglicherweise muss man hier gar nicht ständig neue Objekte erzeugen.
Vielleicht kann man sie sich irgendwo in der Hinterhand halten und dann einfach nur rausreichen.
Gut, das wäre aber ein technisches Detail. Okay,
das heißt, diese Zeile ist jetzt übersetzbar, das ist doch gut.
Ich kann also von außen mir so ein Rational geben lassen,
ohne selber wissen zu müssen, muss,
dass jedes Mal noch euer Zeug findet oder nicht.
Das kann sich später jederzeit ändern. Das ist mir jetzt
egal als Klient. Okay. Gut,
und das ist ja trivial, das sind ja einfach nur irgendwelche Ghetter.
Die kann man mehr gucken. Object. Das ist nicht
richtig. Das war ein Insan. Okay. Dann liefern
wir den mal zurück
Ich glaube, dann ist er auch nicht viel schlauer in
dieser Zeile, oder? Nee, witzig. So. Okay
, das war bis jetzt ja keine Hexenkunst, ne?
Ja. Eine Klasse mit zwei Exemplarvariablen. In Konstrukte werden
die Anfangswerte reingesteckt, der Konstrukt ist privat. Ich habe dafür
eine öffentliche statische Methode, wo das einfach nur weitergeleitet wird.
Und ich kann an die beiden Felder rankommen. Das heißt,
der Test müsste jetzt eigentlich schon durchlaufen, oder?
Ja, wir wollen immer nennen, Wenn ich den mal...
Mir fällt gar nichts Besseres ein, er will immer so.
Okay. Gut. Ich kann jetzt mal etwas,
was man nicht normalerweise in Tests reinschreibt,
ich schreibe es jetzt mal rein, weil ich faul bin.
Ich will dieses A einfach mal auf die Konsole schreiben.
Ich will mal gucken, was da passiert. Hat jemand eine Idee,
was passiert, wenn ich ein Objekt einer Klasse,
die ich selber geschrieben habe, auf die Konsole schreibe?
Kommt dann irgendwie so eine schöne Darstellung, drei Viertel oder was?
Ja. Wenn du das anbietest. Irgendwas mit dem Hashcode
, ne?
Schauen wir mal
Ja, bruchrechnen.rational. 13 at 9-B-C5. Weiß jemand noch,
was man machen muss, damit auf was Hübscheres auf der Konsole erscheint?
Vielleicht mal jemand anders. Wie kann ich beeinflussen,
welcher String auf der Konsole erscheint, wenn ich Systema Quintern benutze?
Ja. Wir können To String überschreiben, sehr schön.
Wollen wir das mal als nächstes machen?
Das ist doch vielleicht ganz nett. Bobs,
dann sagen wir auch explizit, dass wir es überschreiben,
falls uns bei Methodennamen vertippen oder so.
Okay, ja, hat jemand einen Vorschlag,
wie man Dreiviertel auf die Konsole schreiben soll
Ja. Dass wir das Herz dieses Brancheers bringen.
Mhm. Genau. Das probieren wir doch gleich mal.
Ob diese Methode jetzt aufgerufen wird? Ja. Nicht schlecht. Und ich glaube,
man kann sich das hier sogar sparen, Das müsste auch gehen,
weil Elt plus String geht genauso wie String plus Inch.
Ja, genau. Okay. Ach,
da können wir gleich einen Test für schreiben.
Dann muss ich das nicht so hässlich hier reinpacken.
Nennen wir das doch mal Test, Joe String oder so.
Ja, machen wir uns ein Rational. Ach,
wir können doch dieses Dreiviertel, das ist so nett,
das tue ich mal, das tue ich mal außerhalb der Methode,
dann kann ich das hier auch verwenden.
Das finde ich ganz nett. Vielleicht nehmen wir es noch
um, nennen wir es mal.
Hallo? 3-3-Quarters
Das ist schon ein bisschen sprechender. Das ist ja
hier sehr beschäftigt. Dann kann ich da direkt sagen,
ich erwarte, dass dieser String rauskommt,
wenn ich auf Reequalters... True String aufrufe.
So. Gleich wieder testen. Jo. Nett. Okay,
was will man denn sonst so mit Brüchen machen?
Also das Paket heißt ja, oder ja, hier Bruchrechnen.
Bis jetzt rechnen wir ja noch nicht so viel, ne?
Was ist die einfachste Rechenoperation auf Brüchen? Ja,
einer hat sofort eine Idee, vielleicht mal die anderen.
Ja, einer tut das heute noch nichts,
Multiplikation ist tatsächlich das Einfachste, weil man da nicht
so kompliziert irgendwas, Nenner gleich machen muss und so.
Okay. Ach, fangen wir doch mit dem Test an,
das macht total Spaß, zuerst die Tests zu schreiben.
Ich mache mir hier oben nochmal vielleicht One-Half oder so,
One-Half, schreibt man das so?
Ich glaube, ja. Dann nehmen wir mal so,
ach, da fehlt das Off.
So. Okay. Ja. Dann, wie wollen wir es
mal nennen,
Multiplication oder so
Okay. Also, was soll rauskommen?
Muss ich gleich mal überlegen. Wenn ich,
und wie soll denn jetzt überhaupt die Syntax dafür sein?
Wie soll die Syntax aussehen? Und diese beiden Brüche miteinander
zu multiplizieren. Können wir einfach mal Vorschläge sammeln, oder?
Also, das war hier noch von letzter Woche.
Wir sind jetzt in Vorlesung 12. So, also ich habe,
sagen wir mal, die heißen A und B,
da muss ich nicht so viel tippen.
Also, ich will quasi mathematisch, will ich dieses A mal B haben.
Jetzt kann ich aber in Java nicht sagen,
ich will dieses Sternchen, diesen Sternchen-Opperator für meinen eigenen Bruchtyp haben.
Das geht leider nicht. Also, wie müsste man es
stattdessen schreiben, wenn ich A und B multiplizieren will?
Oder welche Variationen fallen euch dann ein
Eine Frau zu bauen. Ja, einfach direkt,
das wurde dann quasi so aussehen, oder?
Mhm. Die wieder in Rational Zeug liefert, ne?
Genau, das ist eigentlich so die erste Idee,
auf die man so kommt. Was man auch machen kann,
manche finden das hübscher, dass sie sagen,
ich rufe eine statische Methode auf und übergebe diese beiden Parameter.
Manche finden das irgendwie hübscher,
weil sie sagen, das A und B, ja,
weder das A noch das B hat ja eigentlich eine besondere Rolle in dieser Multiplikation.
Und hier sieht es irgendwie so aus, als wenn das A
was Besonderes ist und das B ist nur ein Parameter.
Tja, mein Gott. Vielleicht, wir können uns dann
auch über die Namen vielleicht ein bisschen streiten.
Muhl. Hat jemand
andere Vorschläge
Also wie... Man würde jetzt ja auch zum Beispiel nicht im Deutschen sagen,
ah, ich interessiere mich für den Wert von ein Halbmuhl, dreiviertel.
Was würde man stattdessen sagen? Man würde mal sagen,
ne? Okay, und was ist mal auf Englisch?
Mache ich jetzt, glaube ich, nicht Mai, oder?
Times. Also man könnte sowas schreiben wie A.Times B.
Das liest sich doch... Also ich finde,
es liest sich ganz nett,
weil man kann es einfach vorlesen und jeder Mensch,
der das schon mal gehört hat,
versteht sofort, was gemeint ist.
Ich würde vorschlagen,
wir machen es so
Gut. Also, Three Quarters Times. One Half.
Ach, das ist doch irgendwie ganz nett, oder?
So, was kommt denn da raus?
Was ist denn ein Halbmal Dreiviertel? Kann ich das
nicht markieren? Nee, Fragezeichen kann man nicht markieren.
Was ist ein Halbmal Dreiviertel? Wann lernt man das?
In der dritten Klasse? Keiner? Dieser eine konkrete Fall
. Das kann ja eigentlich fast gar nicht sein,
Drei Achtel, sehr gut. Man muss ja Zähler und Nenner
, unabhängig voneinander multifizieren. Also, so, ne?
Was hat er jetzt hier gemacht? So, machen wir,
dass ihr alles seht. So, was will er jetzt
? Ja, Times gibt es natürlich nicht, ne?
Müssen wir implementieren. Oh, habe ich mich irgendwo,
da fehlt der Plural. Deswegen hat er euch beschwert.
Genau. So, jetzt beschwert er sich, dass es das nicht gibt.
Soll er das doch mal machen? Aber er denkt wieder,
das ist ein Objekt sein sollen, weil keine Ahnung warum.
Der Paramtername ist auch nicht so sinnvoll. Ich nenne das
mal Vad. Also das Objekt, worauf es aufgehoben wird,
ist ja Wiss und dann ist der Parameter Vad,
dann kann man irgendwie ganz nett damit arbeiten.
Jetzt hatte ich es ja gerade schon verraten.
Man muss die Zähler multiplizieren und die Nenner auch.
Was muss ich denn jetzt hier schreiben? Also ich habe
einmal das Objekt, auf dem das aufgerufen wurde.
In diesem Fall ist das Three-Quarters. Da kann ich einfach
direkt hier oben auf diese Exemplarwareplan zugreifen. Ich weiß,
dass das dann drei sein wird und das wahrscheinlich viel.
Und dann kriege ich noch ein zweites Rational-Objekt reingereicht.
Das ist in unserem Fall das One-Have. Und wenn ich da
dann auf diese Varianten zugreife, kriege ich eine einzelne zwei.
Wie kann ich die jetzt sinnvoll multiplizieren und wieder in so
ein Rational-Objekt reinpacken
Ah, du. Äh, Nummer weiter, ja?
Okay, was will ich, soll ich mir das in
der Variable tun oder so?
Oder geht es noch weiter
Ja. Ah, du willst, ah,
jetzt verstehe ich, was du machen willst.
Du willst quasi so machen und dasselbe mit Denominator.
Also, ich will es nur mal hinschreiben,
dass wir über dasselbe reden. Das wolltest du machen,
ne? Okay, warum sollte ich das nicht tun?
Hat irgendjemand eine Idee? Kam das in der Vorlesung
dran oder ist es irgendwie klar, ja?
Das wird ja wert und da verändern wir gerade diesen einen Lehrer.
Genau, wir wollen keine Werte verändern.
Ich will also ein A und ein B miteinander zu einem
C verknüpfen
Also wenn ich drei Viertel und eineinhalb multipliziere,
will ich nicht, dass ich das Dreiviertel an sich ändert.
Komisch, dass er mich hier gar nicht warnt,
dass ich das versuche. Vielleicht ist es eine ganz gute Idee,
um sich gegen solche Versehen zu schützen,
die Dinger hier um Final zu machen.
Dass jedem Programmierer sofort auf die Finger geklopft wird,
wenn er versuchen sollte, solche Änderungen vorzunehmen.
Jetzt warnt er mich, dass es nicht in Ordnung ist.
Hast du eine Idee, was ich stattdessen machen soll?
Ja, ja, ja. Okay,
also Return New Rational,
die Ergebnisse
Genau, das klingt doch gut. Also dann nehme ich
mal das. Diese Multiplikation ist der erste Parameter. Und
diese Multiplikation ist der zweite. So. Okay. Das passt
nicht mehr auf den Bildschirm, das irritiert mich ein bisschen.
Vielleicht tue ich doch mal in lokale Variablen.
Da muss man nicht so viel Zeug in einer Zeile verstehen.
Unter der Haube wird wahrscheinlich exakt dasselbe passieren,
aber einfach damit es ein bisschen einfacher verständlich ist.
So, ne? So, ich finde das
ein bisschen hübscher
Okay. Gut, gehen wir wieder in unsere Testklasse.
Hier ist unser Multiplikationstest. Schauen wir mal,
ob er, doch, pass mal auf den Bildschirm.
Oh. Das ist ja komisch, funktioniert nicht.
Dann schau doch mal, was er mir hier sagt.
Hier. Also, er erwartet als Ergebnis drei Achtel.
Seht ihr das hier? Kann man das lesen?
Ja, ne? Drei, achte. Und
was hat er jetzt tatsächlich vorgefunden
Drei Achtel. Tja, das ist nicht dasselbe, ne?
Es ist nicht dasselbe. Denn was macht dieses Assert Equals?
Dieses Assault Equals ruft ja die Equals-Methode auf, ne?
Wo ist die Equals-Methode in unserer Klasse? Nirgends. Ja,
das heißt, da wird einfach die Equals-Methode der Klasse Object genommen.
Wir können da sogar mal reinspringen.
Wollen wir noch mal aus Spaß reinspringen, die Equals-Methode?
Ich gehe jetzt mal völlig sinnlos irgendwo rein,
sag mal irgendwie this.equals, das ist jetzt ein völlig sinnloser Aufruf,
Entschuldigung, das gibt es ja nicht.
Und wir schauen uns einfach mal an,
was diese Equals-Methode macht,
wenn ich die nicht selber
sinnvoll ersetze
Hier sind wir drin. Das ist die Equiels-Methode der Klasse Object.
Was passiert hier? Also Equiels aufzurufen auf einem Objekt und
ein anderes Objekt zu übergeben, führt das hier aus.
Das bedeutet das. Ja. Ist das eine Meldung?
Nee. Was passiert in dieser Zeile? Ja. Wenn
wir dann noch agieren, wenn wir jetzt ein paar Bänder,
wenn wir das wissen und das, okay,
dann kann Fabi wieder gebrauchen.
Dasselbe Objekt im Speicher. Und das ist es ja nicht
. Okay, das nehme ich also wieder raus.
Also nur, dass wir uns das klar machen,
worum es nicht so ist.
Also hier wurde ja intern
dieses New aufgerufen
Und hier wurde auch intern dieses New aufgehoben.
Das sind also definitiv zwei Java-Objekte im Java-Heap.
In dem einen steht die 3 und die 8 drin,
in dem anderen steht auch die 3 und die 8 drin. Ja,
und dieses Equels, dadurch, dass ich jetzt nicht gesagt habe,
was Equels auf Rationals bedeuten soll, sagt jetzt,
naja, die liegen ja an verschiedenen Stellen im Speicher,
dann sind sie nicht gleich.
Das wollen wir aber nicht für Wert typen.
Für Wert typen wollen wir eine andere Art der Gleichheit haben.
Und deswegen müssen wir das Equels von Hand ersetzen.
Tja, machen wir es doch mal. Haben wir,
glaube ich, schon mal ein SE1 gemacht,
das Thema Equels und Hashcode, falls ihr euch erinnert.
Also, ich liefe einen Bulien zurück,
die Methode heißt Equels, sie kriegt ein anderes Objekt entgegen.
Tja,
und nun
Ich habe ein leichtes Déjà-vu. Ich glaube,
wir hatten so ein ähnliches Problem schon mal, oder?
Ja. Das bringt nichts. Ach, du willst einfach
die Strings vergleichen? Zwei, drei Stunden. Okay,
also du willst den String vergleichen? Das könnte man machen.
Das wäre wahrscheinlich die einfachste Möglichkeit. Das Blöde wäre dann aber,
du könntest einen Resional mit einem String vergleichen und es würde
zufällig Na, ich will es einmal machen.
Ich will nicht immer so theoretische Diskussionen machen, das versteht keiner. Also,
du hast gesagt, quasi, wenn mein to string,
oder den gleichen String zurückliefert wie to string auf diesem Objekt.
So, gut. Das war dein Vorschlag. Hier steht
er. Und dann führe ich die Tests nochmal aus.
Und das wird jetzt wahrscheinlich funktionieren. Ja, sehr gut
. Jetzt muss ich aber nochmal einen Test schreiben,
der zeigt, warum das keine gute Idee ist.
Also, Public Volt. So, also ich kann jetzt
zum Beispiel sagen, Ähm... So. Und ich will es
einfach nochmal auch andersrum testen. Man hat ja so,
intuitiv würde man ja denken, Gleichheit,
man muss ja, wie heißt das, kommutativ,
also A gleich B und B gleich A,
sollte ja dasselbe Ergebnis sein.
So. Schauen wir mal, was jetzt passiert.
Hm. Okay. Also dieser Test, Läuft durch,
ja, Three Quarters und der Stream dreiviertel ist gleich.
Aber dieser Test, drei Viertel und Three Quarters,
das Gleiche läuft jetzt nicht durch. Tja, ja.
Ja, genau, und das macht man auch normalerweise.
Also, das kommentiere ich mal aus.
Wir prüfen erstmal, ob es ein Rational ist.
Es ist eine gute Idee. Also, wenn,
that ins, don'ts of rush, so, ne?
Okay, was wollen wir dann machen
Ja. Dann wollen wir den Vergleich von oben machen.
Ach so, dann willst du die Strings vergleichen.
Ja. Hat jemand, okay, das wurde wahrscheinlich funktionieren.
Hat jemand eine Idee, wie man das ohne dieses Trustring macht?
Ich will nicht erst Strings generieren müssen, ja?
So? Das muss jetzt in der eigenen Variable,
nennen wir das mal, Hubs, Radsional,
ja.
So? Okay
. . Ja. Ja. Nee,
wir machen es damit gleich, aber es sind ja Ins.
Oder Air. Nummer weiter, ne? Mhm. Und
die nennen er wahrscheinlich genauso, ne?
Und das Ganze ein bisschen Return, oh Gott,
das ist eine lange Zeile.
Ja. Okay. Warum beschwert er sich jetzt noch
Weiterentwickeln. Vater, die danach auch dann mit dem Vater.
Genau, also falls wir versuchen,
mit dem String zu vergleichen oder mit irgendwas anderem, genau.
Gut. Mir fällt gerade auf,
ich fände es eigentlich schon ganz gut,
wenn diese Variable Thead heißen würde, ich nenne die hier oben mal
Optisch, das ist eigentlich so das, wie man sie normalerweise nennt.
Und dann nenne ich die hier unten mal That.
Das gefällt mir besser. Dann habe ich hier diese schönen Wissen und Bettvergleiche.
Okay, vielleicht tun wir das mal in eine eigene Zeile,
macht er das von alleine, ja.
Okay. Das ist so die Standardvariante,
wie man Equiels implementiert, hatten wir schon in SE1,
aber ist halt schon
ein bisschen her,
Okay, jetzt kann ich also meine Blödsinnstests hier vielleicht wieder löschen.
Die werden jetzt beide fehlschlagen. Das ist aber ganz gut
. Ja, genau, ne? Weil es macht einfach
keinen Sinn, ein String mit einem Rational zu vergleichen.
Das sind einfach zwei verschiedene Typen. Guido hat ja gesagt,
String und Werttyp ist zwei verschiedene Dinge.
Okay, weg damit. Okay, jetzt sind nur Tests übrig,
die laufen, ne? Ja, sehr gut. So,
jetzt überlege ich gerade, wir sind uns jetzt ja ziemlich sicher,
dass diese Multiplikation funktioniert, ne?
Ich will mal einmal einen blöden Fehler einbauen
Ich vergesse die Multiplikation. Kann ja mal passieren.
Mal gucken, was die Tests sagen. Oh,
es läuft alles noch. Kann ich diese Multiplikation wegoptimieren?
Warum gibt das denn jetzt keinen Fehler? Wollen Sie
den Test nochmal angucken? Ja, dieser Test ist das
ja, wo ich drei Viertel mit anhalb multipliziert habe.
Wieso gibt es keinen Fehler, wenn ich werde heute
noch nicht?
Weil ich mit eins multipliziere. Das ist ziemlich blöd. Das heißt,
wir sollten auf jeden Fall nochmal irgendeine andere Zahl haben,
zu multiplizieren, welche wollen wir nehmen?
1, 2, 3, 4 haben wir schon,
dann nehmen wir 5 Sechsel vielleicht. 5, 6. So,
ne? Dann ist eigentlich der One-Have-Test auch nicht besonders sinnvoll.
Ich multipliziere dann auch nur mit 5, 6, 6.
Und was kommt denn da jetzt raus?
3 mal 5 ist
4 mal 6 ist 24. So, der schlägt jetzt fehl,
weil ich immer noch diesen Fehler habe.
Ich weiß nicht, ist das nicht so eine merkwürdige Format?
So, und jetzt mache ich den Fehler wieder weg.
Und jetzt müsste der Test hoffentlich wieder durchlaufen.
Ja. Warum ist das so komisch? Weil deswegen Vollbild?
Nee. Okay. 15.24. Das ist ein komischer Bruch,
oder? Oder er ist nicht so hübsch.
Warum ist 15.24 nicht
so hübsch
Ja. Man kann ihn kürzen. Ja,
das heißt, das fände ich eigentlich ganz gut,
wenn wir dieses Kürzen hier einbauen,
also wenn ein Klient gar nicht die Möglichkeit hat,
einen ungekürzten Bruch sozusagen aus Versehen zu erhalten.
Ja, wo wollen wir das denn mal reintun?
Vielleicht hier in diesen Konstrukt oder eines sichergestellt,
dass es auf jeden Fall gekürzt ist
. Ja, wie kürze ich das denn jetzt?
Hm. Wie kürzt man einen Bruch,
wenn man das in der Schule per Hand macht?
Was muss man dafür
erstmal rausfinden?
Das könnte man machen. Alle Primfaktoren und so, das wird,
glaube ich, ziemlich umständlich, das schaffen wir heute nicht.
Hat jemand eine andere Idee? Es reicht, eine Zahl rauszufinden.
Ja. Den größten gemeinsamen Teiler, ja. Wir brauchen also
einmal eine mathematische Funktion, die den größten gemeinsamen Teiler bestimmt.
Ich mache die mal hier als private Hilfsfunktion,
damit die mal G-G-T, wie größter gemeinsamer Teiler.
Sie kriegt ein A und ein B rein, Turno.
Dann gibt es den sogenannten Algorithmus von Euklit.
Ich habe mir den extra nochmal angeguckt. Ich hoffe,
ich kriege das hin. Der ist so schön rekursiv formuliert.
Also, wenn B-0 ist, kann ich einfach A zurückliefern.
So. Ansonsten liefere ich zurück den größten gemeinsamen Teiler von B
und A,
Puh, ja, oh, es funktioniert nicht.
Arche den Ergebnis-Typen vergessen. Das ist ein Int. So.
Gut, ich hoffe, ich habe mich nicht vertippt.
Könnt ihr euch in Ruhe heute Abend mal ins Bett legen
und euch davon überzeugen, dass das hier wirklich funktioniert.
Gut. Ja, dann bestimmen wir den nochmal.
Also, unter GET von Doktor. Das wäre ja in
unserem Beispiel 15, 24, 3, oder?
Genau, das wäre in unserem Beispiel 3. Was mache ich
jetzt mit der 3?
Du willst ja erstmal nur bestimmt
Ja. Genau, und das heißt,
ich teile das einfach hier. Ich merke gerade,
ich mische hier schon wieder Englisch und Deutsch,
das ist irgendwie nicht so gut, oder?
Was heißt denn Tyler? Tyler heißt ja die Viso,
glaube ich. Und dann heißt es auch nicht GGT,
sondern Greatest Common Devisor. Ach, wisst ihr was,
ich schreibe das einfach hin. Greatest, Common Devisor.
Ja, dann liest sich das doch gleich wie schöner.
Also Devisor gleich Greatest Common Devisor, okay.
So, jetzt wird der Test natürlich nicht mehr funktionieren.
Oh doch
Wird der Test jetzt funktionieren oder fehlschlagen? Da kommt jetzt
ja nicht mehr 15, 24. raus, ne?
Wer ist dafür, dass der Test jetzt fehlschlägt, Amaranto?
Ja, ein, zwei, wer glaubt, dass er nicht fehlschlägt?
Die deutliche Mehrheit von Fände. Schauen wir mal. Tja
, Tatsache funktioniert, ne? Weil ja, hier,
wenn ich dann mal in die Methode Value auf reinspringe,
wird ja der Konstrukt da auch gewonnen und da wird ja
genauso gekürzt
Das heißt also, sowohl dieses Ergebnis, was erstmal intern temporär,
15, 24. ist, wird dann intern gekürzt.
Und diese Anfrage des Klienten 15, 24, wird genauso gekürzt.
Das heißt, was jetzt aber zum Beispiel nicht mehr funktionieren würde,
wäre zu sagen, gut, hier sind jetzt keine Ungeteilten.
Also wenn ich mir zum Beispiel den String holen würde hiervon,
ich mache das mal kurz als Test,
das durch Klaas ist, was ich meine.
Wenn ich also hier schreiben würde, ich erwarte,
dass hier 15, 24 wieder rauskommt,
wenn ich das als String kombiniere,
das wird jetzt nicht mehr funktionieren.
Das werdet ihr erzählen
Hier, ne? Oh, ist hier. 15,
24. habe ich hier Expected, aber tatsächlich ist es 5,8. Ja,
aber ich finde, ich finde das mit dem,
mit dem Kürzen eigentlich ganz gut.
Das heißt, das kann ich eigentlich gleich als weiteren Test für aufnehmen.
Was war das jetzt? 5,8, ne? So. Jo
. Okay, was wollen wir mal als nächstes machen?
Multiplikation haben wir. Greatest Common Device haben wir auch.
Ich glaube, die schwierigsten Dinge haben wir schon.
Die Division, die ist, glaube ich, recht trivial schon fast, oder?
Machen wir erst wieder den Testfall, das macht Spaß.
Testriven-Development. Okay. Was momentan mal dividieren?
Das muss ja auch irgendwie genau hinkommen, ne?
Kommt hier irgendwas? Ah ne, muss es gar nicht,
das sind ja Brüche, ich kann ja dividieren,
was ich will, das geht ja alles.
Was wollen wir machen? Wollen wir mal fünf,
sechstel durch drei Viertel dividieren?
Machen wir das einfach mal sehen, was da rauskommt.
56. Ja, die Methode gibt es noch nicht,
wir wollen sie nennen
Die Methode zur Division. Bei Marley hatten wir Seed Times
genannt, was heißt durch? Gibt es da irgendwas Schönes
? Die weidet bei, das wäre ganz nett.
Gibt es noch irgendwas, was ein Wort nur ist?
Sagt man nicht manchmal over im Englischen,
eine One Over 2 oder Five Over Six,
könnte ich dir so... Ich schreibe es einfach mal hin und nachher
machen wir eine Abstimmung und wenn es euch nicht gefällt,
nehme ich es anders.
Five Six over, was würde ich sagen,
Three Quarters, ne? So. Okay, das muss ich
noch mal ganz kurz per Hand machen,
also 5 Sechstel
Durch drei Viertel. Okay, das ist ja dasselbe wie
fünf, sechste Mal vier Drittel. Okay. Und das
ist dasselbe wie fünf mal vier durch sechs mal drei.
Ist das so richtig, was ich mache? Das wäre
dann 20 durch 18, also neun, neun Achtel.
Gibt es Einwände, habe ich mir irgendwo verrechnet.
Was? Oh, danke. Was habe ich
denn da gemacht
Ich habe euch natürlich nur getestet, ob ihr nicht schlaft oder so.
Zehn Leute? Okay. So. Okay. Was passiert eigentlich
, wenn ich jetzt das ausführe? Ich meine,
das ist ja eigentlich gar nicht übersetzbar, aber ich glaube,
in Eclipse kann man es trotzdem ausführen.
Ich mache das einfach mal. Was sagt er jetzt?
Achso, hier. Okay, also zur Laufzeit beschwerte sich,
dass es die Methode gar nicht gibt.
Witzig. Ja, dann machen wir die Methode doch mal.
Das ist wieder ein Rational, ups.
Ne,
haben es jetzt
Da bin ich. Das ist natürlich völliger Unsinn,
das nennen wir mal That. Ja, hat jemand
einen Vorschlag? Ich hatte ja eben schon gezeigt,
wie man es per Hand machen würde.
Also man muss, wenn man durch einen Bruch dividieren will,
dann muss man nur multiplizieren mit dem Kehrbruch.
Wie kann ich das halbwegs sinnvoll in Java sagen?
Ja. Bisschen lauter bitte, meine Ohren sind schon alt.
Ja. Okay, und kannst du das
auch in Java-Quelltext formulieren,
was ich dann tippen müsste
Ja. Von welchem Typ ist die Variable?
Okay. Und was soll ich da jetzt machen?
Du willst jetzt quasi den Kehrbruch berechnen, oder?
Ah, okay. Was heißt im Kehrbruch,
ich nenne es erst mal Kehrbruch,
wenn jemandem das englische Wort einfällt, kann das mir ja sagen.
Gut, dann sage ich also Rational Punkt Value Off,
Ja, will ich jetzt meinen eigenen Kehrbruch bilden und in
den Kehrbruch vom Wett? Das ist ja eigentlich egal,
ne? Nee, ich mache von mir selbst.
Da komme ich einfacher ran. Sehr gut, ja.
So, ne? Habe ich jetzt richtig? Hier,
von mir selten drin. Jetzt heißt es wieder die anderen,
von deinen eigenen noch nicht, dein eigener Bruch und den anderen.
Stimmt, dann müsste ich am Ende nochmal eine Kehrbruch bilden.
Sehr gut, ist also auch falsch. Ah.
Toll, dass du jedes Mal in der Vorlesung bist.
Ähm, so, ne?
So. Okay. Und wie geht's weiter? Also ich habe
jetzt den Kehrbruch von meinem Parameter gebildet und jetzt.
Muss ich noch multiplizieren. Wie mache ich das?
Ja. Achso, das wolltest du mir sagen.
Inverse. So. Okay, und was muss ich jetzt schreiben?
Wie mache ich jetzt die Multiplikation? Ich will mich selber
mit dem Kehrbruch multiplizieren. Wie geht das?
This times inverse, genau. Toll. Okay,
mal gucken, ob
der Test funktioniert
Das ist jetzt hier dieser Test. Jo. Also entweder
haben wir keinen Fehler gemacht oder ich habe in der
handschriftlichen Rechnung genau denselben Fehler gemacht wie eine Implementation,
könnte ja theoretisch auch sein.
Gut. Okay, ach wir haben noch ein paar Minuten.
Wollen wir die Atdition noch kurz machen?
Was wollen wir denn da mal addieren? Machen wir,
auch nicht über dieselben Zahlen. Dreiviertel und fünf Sechsel addieren,
das macht doch bestimmt Spaß.
Ich weiß wieder nicht, was rauskommt und ich will 5,
6, 5, 6 nennen.
Plus nächstes Mal, das klingt toll. Plus drei Viertel
. So, da muss ich jetzt mal gucken.
Ach, vielleicht kann ich das sogar ein bisschen hübscher machen.
Dann sieht es aus wie in der Schule.
Fünf, sechste, ha. Plus, drei Viertel.
Ja, wie gehe ich da jetzt vor?
Okay, also ich muss hier irgendwie bei Kreuz motivieren,
also es wäre fünf mal vier durch sechs mal vier.
Oh, was habe ich hier geschrieben? So. Genau,
das ist also quasi dann, so, da haben wir
es auf einen Nenner gebracht quasi. Okay. Gut,
also ich muss den Zähler mit dem anderen Nenner multiplizieren,
dann den Zähler mit dem anderen Nenner,
das ist dann der neue Zähler und der Nenner,
das ist die Multiplikation der Nenner,
das kriege ich glaube ich selber hin,
oder?
Achso, ich muss erst mal den Test schreiben,
was kommt denn da raus
Also unten haben wir 24. Was haben wir oben? 5x4 ist 20 und 18,
38. Okay, und das müssen wir jetzt noch kürzen.
Also man kann es durch zweiteilen, man kann,
ja durch zwei, da haben wir oben eine 19,
das ist eine Primzahl.
Okay, also wir müssten das 19 Zwölftel sein.
Einwände, dann ist jetzt der richtige Moment.
Gut, 19.12. 19.12. So, habe ich mich hier
schon wieder fixe,
das ist falsch
Okay, er will wieder ein Objekt zurückliefern, das nennen wir wieder That.
Okay. So, was hatte ich jetzt gesagt? Also,
mein eigener Zähler, multipliziert mit dem anderen Nennern,
plus der andere Zähler multipliziert mit dem eigenen Nenner, ups.
So. Und das jetzt teilen durch meinen eigenen Mal von dem anderen.
Ach. Wollen wir das nicht? Doch, genau.
So, die Zahl ist schon wieder viel zu lang.
Zwischenvariablern. Boah, ist das lang.
Passt ja schon der erste Parameter nicht auf dem Bildschirm.
So. So. Ist das nicht unglaublich,
was man in der vierten Klasse schon alles konnte?
So. Simicolon. Okay. Ja,
dann schauen wir mal,
ob der Test läuft
Hier ist unser Test. Ah ja, sehr gut. So,
einen Test wollte ich noch ganz gerne mit euch machen.
Den vergisst du immer ganz gern. Collection. So,
ne? Also, ich mache mir mal eine Collection.
Ich kann diese Rationals ja auch in Mengen reintun.
So. Okay, dann tun wir doch mal 22 Siebtel,
das ist ja ungefähr
Okay. Und dann fragen wir mal, ob das 22.7. da dran ist.
Okay. Oh, was habe ich jetzt gemacht?
Wow, das würde ich importieren. So. Okay,
also am Anfang ist das Set leer, dann tue ich
22.7. rein und dann frage ich, ob 22.7. bülterin ist.
Hand hoch, wer glaubt, dass es drin ist?
1, 2. Okay, wer glaubt,
dass es nicht drin ist
Eins, zwei, oh nee, da kratz ich jemanden an der Nase.
Okay, unentschieden. Andi, da sind noch zwei Hände.
Okay. Ja, schauen wir mal. Huch? Ich
hab's auch reingetan, warum ist es denn nicht drin?
Das ist ja merkwürdig. Du musst mal auf die Konsole schreiben.
So. Ja, da ist es doch. Vielleicht, merkwürdig
. Vielleicht gehen wir noch mal mit einer Vorschlafe rüber.
Ich will mir mal jeden Rational Air in diesem Set angucken und vergleichen,
ob er Equiels ist mit 22.7. Ist das wirklich 22.7.,
was da drin ist?
Wo ist mein, warum wird hier jetzt nichts auf
die Konsole geschrieben? Achso, weil er da schon,
weil er da schon abbricht, wenn wir hier runtertun.
Aha, also es ist wirklich zwangs, also es sieht so aus,
als ob 22.7. drin ist und es ist auch wirklich drin.
Ja, aber ich sag mir, dass es nicht drin ist.
Warum das denn? Irgendjemand eine Idee? Keine Idee?
Das Contains ruft tatsächlich die Equiels-Methode intern auf, aber es macht noch mehr.
Erinnert sich noch jemand wie ein Hash-Set intern aufgebaut ist?
Ja. Ja. Ja. Sehr gut. Ich schreibe
das noch mal kurz hin. Wenn a.equielsb gilt,
dann muss auch a.hash-code gleich gleich b.hash-code gelten.
Sonst habt ihr merkwürdige Effekte. Wenn ihr eure Werte in
Sammlung reintut, das machen wir mal kurz zusammen,
das geht ganz schnell
Also ein Hashcode. Ja, hat jemand einen Vorschlag?
Wie ich jetzt aus dem Zustand dieses Rash-Nerds,
diese beiden Zahlen, einintgenerieren kann, sodass sichergestellt ist,
ja, wenn es das aus denselben Zahlen derselben Hashcode generiert wird,
irgendein Vorschlag, wie kann ich zweiins zu einem End verwursten?
Hönge, deterministische, mathematische Funktion, die zweiins zu einem
macht.
Keiner eine Idee
Tja, dann nehme ich mal so der Standardmuster,
man nimmt normalerweise die erste Zahl,
multipliziert sie mit 31 und hört die zweite Zahl rauf.
Ihr hättet aber auch jede andere mathematische Funktion nehmen können. Ja,
ihr würdet auch sagen, ich nehme nur den Zähler,
sonst wären sie nicht ganz so schön verteilt.
Ihr hättet, auch das X-Or, hätte man auch nehmen können.
Falls euch mal langweilig ist, guckt mal nach,
was dieser Operator macht, der passt hier eigentlich noch besser,
um zwei Inzahlen zu einer zu machen.
Okay, ja, gibt es noch irgendwelche Fragen zu dem,
was man, ich fasse noch mal ganz kurz zusammen.
Also, wenn ihr eure eigenen Werttypen bauen wollt, müsst ihr auf ein paar Dinge aufpassen.
Erstmal, die Exemplarvariapt und die Java-Exemplarva sollten Final sein,
dass sie sie nicht aus Versehen ändert. Dann sollte der Konstruktor Private sein,
dann sollte es eine öffentliche statische Methode geben,
Die nennt man meistens Value oft geöffnet,
also Select nennen oder wie ihr wollt,
wo man die wichtigen Daten reinsteckt und die delegiert einfach nur an den Konstruktor.
Dann will man so gut wie immer an die einzelnen Felder rankommen,
ein bisschen muss man aber vielleicht nicht in jedem Fall.
To String ist ganz nett zu haben, finde ich,
wenn man mal so Debugging macht. Und das Interessante ist,
dass die Methoden, die jetzt so rumrechnen mit euren Werten,
dass die eben keine Veränderungen vornehmen,
geht ja gar nicht, die Exemplarwerten sind ja Final,
sondern dass ein anderes Rational Objekt zurückgeliefert wird.
Das ist eigentlich so der Knackpunkt bei den Werttypen.
Dann müsst ihr in Java noch darauf achten,
dass sie das E-Quels korrekt überschreibt, wenn man E-Quels überschreibt,
muss man auch Hashcode überschreiben.
Ja, und das hier ist dasselbe Muster wie oben
Verändert nicht den Rational, sondern man liefert einen neuen Rational zurück.
Und das macht das Testen von solchen Wehrtypen extrem hübsch.
Ihr müsst also fast nie irgendwelche Objektgeflechte erst mal zusammenbauen und
irgendwann fangt ihr mal an zu testen,
sondern man kann fast immer eigentlich direkt loslegen, zu fragen,
was kommt denn hier bei der Funktion zurück,
was kommt bei der Funktion zurück.
Und ihr müsst nie sagen, okay,
am Anfang ist Recorders in dem Zustand,
jetzt ändere ich es ein bisschen und dann erwarte ich,
dass es in einem anderen Zustand ist.
Das ist schon ein ganz netter Vorteil bei Wehrtypen,
dass das Testen so einfach dann gemacht wird.
Ja, wir haben noch gar nicht geguckt, ob das jetzt durchläuft.
Machen wir jetzt auf der Balken Grünes. Wenn der Balken
Grünes dürft ihr gehen, ansonsten müsst ihr sitzen bleiben.
Okay, ihr dürft gehen