3, 2, 1, 14.15 Uhr. Liebe Experten. Und Expertinnen,
also das ist genau das, wozu wir sie ausbilden hier.
Sie werden also Purpoin Dicularity, können sie spuchstabieren und definieren.
Und dann sollen sie sieben orthogonale rote Linien mit drei Transparenten dazwischen zeichnen können.
Viel Spaß im Berufsleben. Und dann wissen sie,
warum sie das jetzt alles gelernt haben, dass wir ihnen hier beibringen.
So, ihr habt ja schon in der ersten Vorlesung gesagt, Software wird nie,
nein, nicht nie, aber wird immer für jemand anders entwickelt.
Und den Aspekt der anderen, den werden wir im Rahmen
dieser Vorlesung, werden wir das also nicht wirklich behandeln.
Vielleicht SE2 ein bisschen, aber dann insbesondere,
weil wenn es um Softwaretechnik geht, werden wir dieses Thema noch weiter beleuchten.
Heute geht es dagegen, um ganz, ganz irdische Dinge,
die nur mit ihnen und dem Rechner zu tun haben.
Ich werde aber auch an dieser Stelle versuchen,
Und da ist noch mal ein bisschen aufzulockern,
so im Laufe der Vorlesung zeige ich noch ein Video,
das auch zum Teil dieser Vorlesung gehört,
was so das Thema der heutigen Vorlesung, nämlich Ausdrücke und Typen,
auch noch mal auf eine etwas andere Art und Weise versucht zu beleuchten.
So, das Thema Ausdrücke,
Ausdruck ist auch ein Beispiel dafür, dass das,
also die, warum sowas wie Babelfisch nicht allzu gut funktioniert,
also Ausdruck, wenn ihr steht,
der englische Urbegriff dafür ist Expression,
der englische Begriff ist eben nicht Printout,
sondern das ist Expression
Während dem Rahmen der Vorlesung noch ein paar weitere von diesen Begriffen kennenlernen,
die sich nicht wechselseitig übersetzen lassen oder jedenfalls nicht hin und zurück,
ohne dass es dazu lustigen, nicht über Einstimmung kommt.
Wir beschäftigen uns heute mit Expressions und Sie sehen die,
Sie sehen die Definition von Ausdruck, was bedeutet das,
eine Verarbeitungsvorschrift und das sind im Wesentlichen so das,
was wir hier kennenlernen, sind das wahlweise Arrithmetische oder Bullshit-Ausdrücke,
mit denen wir uns beschäftigen werden.
Also diese Verarbeitungsvorschriften liefern einen Wert und dieser Wert kann im Rahmen einer Zuweisung dann einer Variablen
Ja, im Rahmen meiner Zuweisung, einer war viablen, zugewiesen werden.
So ein Beispiel sehen Sie hier. Und das unter der Voraussetzung,
dass das X hier als eine Intager-Variable deklariert ist.
Wir haben ja drei verschiedene Typen, Arten von Variablen
haben wir im Rahmen der letzten Vorlesung kennengelernt.
Also wenn das als eine dieser Arten von Variablen deklariert ist,
dann, das sollten Sie sich an der Stelle auch schon merken,
dann wird Ihr Java-Programm übersetzt werden und es wird daraus ausführbarer Code
vom Compiler produziert werden.
So,
das sage ich deswegen
Schauen Sie drauf und denken, naja, das ist doch Selbstverständnis, ständlich.
Also warum redet er jetzt so lange da drüber?
Das hängt, das werden wir uns gleich noch,
also vor allem in dem Video werden wir uns das noch anschauen.
Was also diese Art von Ausdrücken, wie die interpretiert werden kann,
in nicht stark getypten Kontexten. Also der Compiler,
einer stark getypten, statisch getypten Programmiersprache,
so wie das in Java bei Java der Fall ist,
also wird diesen Code nur übersetzen, wenn der,
also in Anführungsstrichen sinnvoll ist bzw. der Sprachbeschreibung genügt und wird nicht versuchen,
also irgendetwas anderes daraus zu referenzieren, was möglicherweise,
also auch noch interpretiert werden kann.
Das muss im Fall von Java im Fall einer starken Typen,
statisch getypten Programmiersprache eindeutig sein und für den Fall,
den ich genannt habe, ist das auch so.
So, jetzt habe ich schon davon gesprochen,
dass Ausdrücke im Rahmen von Zuweisungen ausgeführt werden und sie sehen jetzt hier,
so ein erstes Beispiel dafür, wie die Syntax von Programmiersprachen,
wie die allgemein definiert werden kann.
Wir werden die, das generelle Konstrukt, die sogenannte Bakus-Nauerform oder kurz WNF
, werden wir auch noch im Rahmen der Vorlesung vertiefen.
Wird zunächst mal also so ein Ausschnitt aus der BNF,
also für der Bakus-Nauer-Form für Java.
Die sehen Sie hier, nämlich das Syntaxschema der Zuweisung.
Wie sieht eine Zuweisung generell aus? So, das kommt
ganz harmlos daher und ist im Großen und Ganzen auch harmlos.
Man muss das bloß einmal lesen können, also eine Zuweisung,
sieht generell in Java immer so aus.
Sie hat eine linke Seite, was immer das ist.
Sie hat einen Zuweisungsoperator und sie hat eine rechte Seite
Okay, dann fangen wir mal auf der rechten Seite an,
weil, da wie vorhin haben wir gerade schon gesprochen,
die rechte Seite einer Zuweisungsanweisung ist immer ein Ausdruck.
Und so ein Ausdruck liefert einen Wert. Und das ist hier,
wie schon gesagt, ist das ein arathmetischer oder ein Bulshar-Ausdruck.
Das können Vergleiche sein und Zeichen oder Zeichenketten.
Also das sind sogenannte literale, etwas,
was sie in der Sprache einfach hinschreiben können und was als ein Element,
als ein Werte,
als Element der Wertemenge eines Typs eines elementaren Typs verstanden werden kann.
So,
das ist die rechte Seite
Einer Zuweisungsanweisung. In der Mitte steht der Zuweisungsoperator und da haben also viele,
gerade so Menschen mit einem mathematischen Hintergrund haben damit, also ein mentales Problem.
Der Zuweisungsoperator in Java, der sieht aus wie,
dass ihnen aus anderen Kontexten bekannte Gleichheitszeichen. Das bedeutet in Java
aber nicht Gleichheit, wenn man das einfache Gleichheitszeichen hinschreibt,
sondern es bedeutet, hier soll eine Zuweisung stattfinden.
Und dann der Compiler über ihr Programm geht und ein solches Zeichen findet,
dann erwartet er auf der rechten Seite dieses Operators erwartet er einen Ausdruck und auf der linken Seite,
jetzt kommen wir endlich zu der linken Seite,
bezeichnet er, erwartet er einen Bezeichner einer Variable.
Das ist die Zuweisung, so wie sie syntaktisch,
also in Java definiert ist und wenn so eine Folge so interpretiert werden kann,
dann macht der Compiler da mental einen Haken dran und lässt sie das durchgehen oder wird daraus versuchen,
ein Stück ausführbaren Bytecode zu erzeugen unter der Voraussetzung.
Das steht hier nämlich nicht auf, also jetzt auf den Definitionen,
auf den Erläuterungen für linke Seite und rechte Seite,
dass die linke und die rechte Seite sogenannt typ kompatibel sind.
Das bedeutet, Typ kompatibilität. Und nun Kompatibilität bedeutet,
dass das zueinander passt und wir für unseren Kontext hier in SE1 können uns das ganz einfach machen.
Typ Kompatibilität bedeutet, in 98 Prozent der Fälle, Typ Gleichheit. Also das,
was der Ausdruck auf der rechten Seite einer Zuweisung liefert,
das, was der Wert, der hier geliefert werden wird,
muss gleich dem Wert der Variablen sein,
die auf der linken Seite steht.
Also den rechts- und Intager-Wert geliefert wird,
dann muss links auch eine Intager-Variable deklariert sein.
Wenn rechts ein Bulschar-Wert geliefert wird, dann muss links
auch ein Bezeichner für eine Bullsche Variable steht.
Wenn das der Fall ist, dann kann diese Zuweisung zur
Laufzeit des Programms erfolgreich ausgeführt werden.
So, hier sehen Sie jetzt ein paar Beispiele für Zuweisungen
In Java, warum ist das hier eine korrekte Zuweisung?
Na, hier steht also ein Intager-Wert und dieser Wert soll
zugewiesen werden an eine Variable mit dem Bezeichner Antwort.
Jetzt hoffen wir mal, dass Antwort vom Typ Intager ist, dann geht das klar.
Die Variable Antwort hat dann den Berg 40. Hier sehen Sie jetzt eine Zeichenfolge,
die ich so in der Form noch nicht erklärt habe,
dass plus gleich bedeutet, ist eine Kurzschreibweise,
also das, was hier steht,
Antwort plus gleich zwei ist eine Kurzschreibweise für Antwort,
ist gleich,
das ist gleich als Zeichen,
gesprochen als Zuweisung
Antwort wird zur Antwort plus 2. Wenn Antwort vorher den Wert
40 hatte, dann hat es nachher den Wert 42.
Und deswegen ist auch diese Zuweisung hier nicht nur syntaktisch korrekt,
sondern wenn wir jetzt hier fragen, Antwort ist gleich,
das ist jetzt so die Frage auf Gleichheit,
hat es den Wert 42, 42 ist gleich 42,
das evaluiert zu True und korrekt,
bekommt den Wert True zugewiesen.
Als sich da jemand gemeldet? Nein, Entschuldigung. So,
diese drei, drei verschiedenen Arten von von Anweisungen,
die sollte man unterscheiden können.
Das hier bedeutet, Saldo bekommt den Wert null.
Das hier fragt, hat Saldo den Wert null?
Und das fragt, hat Saldo einen Wert ungleich null?
Hier wird eine Zuweisung durchgeführt und diese Ausdrücke der Frage nach
Gleichheit und die Frage nach Ungleichheit liefern einen Wert.
Das sieht alles hinreichend ähnlich aus,
wenn man nur so mit einem Auge hinschaut,
hat aber unterschiedliche Bedeutungen und wird in unterschiedlichen Kontexten verwendet
Also das erstmal so zur Zuweisung.
Und jetzt habe ich schon kurz über Operatoren gesprochen.
Sie sehen hier die Definition von Operatur, von Operator.
Was ist das? Also das bezeichnet umgangssprachlich das Operatorzeichen,
als auch die damit verbundene Operation,
also mit einem Operator, wird eine Operation denotiert.
Und hier sehen Sie so ein paar Beispiele für Operatoren,
die so im Umgang mit natürlichen Zahlen,
mit Integern
häufig gebraucht werden
Könnte man es mit den Operatoren so bei sich bewenden lassen,
insbesondere mit den Operatoren, die für die sogenannten elementaren Datentypen,
welche das in Java sind, komme ich gleich zu.
Man könnte es damit bei sich bewenden lassen, tun wir aber nicht.
Wir müssen uns jetzt ein paar Gedanken machen darüber,
was Operatoren im Umgang mit einer Programmiersprache,
was den Umgang damit ausmacht, um mal schauen zu können,
wenn wir später nächste Woche, übernächste Woche anfangen und Selbstoperatoren zu definieren,
was es dabei eigentlich alles zu beachten gilt.
Das machen wir jetzt, also was es dabei zu beachten wird,
kommt jetzt in den nächsten vier, fünf Folien Das machen wir ein Beispiel der elementaren Datentypen,
also insbesondere am Beispiel der Integer,
damit sie von bekanntem Terrain aus ausgehend sich einen Gedanken darüber machen können,
was eigentlich alles zu beachten ist,
wenn man so harmlose Sachen wie 3 plus 3 mal 4 in einer Programmiersprache hinschreibt und vor allem,
was alles passieren kann, wenn man nicht bedenkt, was,
also zum Beispiel mit der Position von Operatoren auf sich hat.
So Position von Operatoren ist etwas, das denke ich,
kennen sie aus der Schulenmathematik,
aus dem Rechnen,
kennen sie das
ganz gut
Also die drei bekannten Arten, auf welche Weise man
Operatoren positionieren kann, die Infix-Notation bei arithmetischen Operationen,
also insbesondere, wenn es zwei Operanten gibt.
Das heißt also, der Operator steht zwischen den beiden Operanten.
Präfix ist dann also bei einstelligen Operatoren, wird es gerne genommen.
Das ist also die, sie sehen hier ein Beispiel,
die Negation für eine Präfix, für einen Präfix-Operator.
Oh Gott
Das habe ich gehört. Und wo eine Präfix-Notation daherkommt,
ist eine Postfix-Notation nicht weit. Ob Fakultät,
ein Postfix-Operator in Java ist, you are the expert.
Sag nicht nein, ich habe noch gar nicht ausgeredet.
Okay, also nicht. Dann müsste man sich den wohl
definieren. So, das ist alles eigentlich ganz harmlos.
Also eine Position von Operatoren ist eine Eigenschaft, die Operatoren haben.
Stelligkeit. Ja, jetzt fragt man sich, wenn die
also unterschiedlich positioniert werden können, da muss ich mir noch Gedanken über die Stelligkeit machen.
Eigentlich nicht, muss man aber doch. Wir unterscheiden also in den handelsüblichen Programmiersprachen,
unterscheiden wir drei Arten von Stelligkeiten, Unnähre, Operatoren,
Fakultät ist hier ein Beispiel oder auch,
also das Einfache, Minus, die zweistelligen,
binären Operatoren oder auch, und hier wird es schon,
also hier kommt es dann so direkt auf die Ebene der Programmiersprachen,
so ein terrnäheren, dreistelligen Operator wie das If Than Ells.
So, man kann nämlich auch die If and Ells Anweisung,
also die Zweigung kann man auch, also als einen Operator betrachten.
Und das ist so das Ziel,
dass so eine Programmierung beim Design an der Programmiersprache wie Java im Vordergrund steht,
mit wenigen orthogonalen, purprint decuna Operators,
mit wenigen orthogonalen Konzepten eigentlich beschreiben können,
was eigentlich möglich ist in dieser Programmiersprache.
Und dann kann man if than Else oder auch die Schleife kommt noch,
als ein Ter näheren Operator betrachten, wobei die Schleife ist,
glaube ich, ein Bienenährer-Operator.
Aber dazu, wie gesagt,
später noch mehr
Konzedenz von Operatoren haben Sie eigentlich auch schon in der Grundschule kennengelernt,
deswegen hier auch nur noch mal ganz kurz,
dass also Punkten vor Strichrechnung geht und dass die,
wie hier in den beiden Beispielen,
dass das so die Klammerung ein unterschiedliches Ergebnis nach sich zieht,
denke ich, ist auch klar.
Aber gerade die Präzedenz, also das wird bei den Operatoren,
mit denen wir uns dann im späteren noch beschäftigen werden,
sollten Sie im Hinterkopf behalten, dass das einen erheblichen Unterschied machen kann,
in dem Moment wo wir mit verschiedenen Operatoren in einer Zuweisung,
in einem Ausdruck arbeiten, da treten dann eben mitunter Effekte auf,
die sie nicht beabsichtigt haben.
Und deswegen ist also die Frage nach,
welche Präzedenzen haben eigentlich die Operatoren,
mit denen ich hier umgehe, ist eine Frage,
die also ungefähr hier bei Ihnen angesiedelt sein sollte,
um nicht lange, allzu lange nach Fehlern in ihrem Programm zu suchen.
So, die letzte Eigenschaft von Operatoren,
die Sie behalten sollten,
ist die sogenannte Assoziativität
Das spielt insbesondere dann eine Rolle, wenn sie eine Zuweisung betrachten,
in der Operatoren mit gleicher Präzedenz vorkommen.
Dann spielt die Assoziativität eine Rolle. Dieses Beispiel,
das ist jetzt auch wieder offensichtlich aus der Grundschularithmetik genommen ist,
dass dieser Ausdruck hier dasselbe Ergebnis liefert wie dieser,
da haben dann doch schon,
das kann man zwar abtun als Grundschulrechnen,
damit will ich mich nicht länger beschäftigen,
ausrechnen können,
sollte man
das trotzdem
So, und die Regeln, sie sehen sie hier.
Also das, worüber wir sprechen, ist,
dass also es gibt sowohl links als auch rechtsassoziative Operatoren.
Und wenn sie dann später mal Selbstoperatoren in ihren objektorientierten Programmen,
also zum Beispiel in einer Programmiersprache,
wie der eben schon genannten Sprache C plus plus definieren,
dann werden sie sich auch darüber Gedanken machen müssen,
in welcher Form die assoziativ sind, also links oder rechtsassoziativ.
Das spielt bei den, also Grundrechenarten spielt es also eigentlich
weniger eine Rolle. Das ist ja wirklich,
wie gesagt, nur als Beispiel dafür,
dass man sich über diesen Gesichtspunkt Gedanken machen muss,
ist es
hier aufgeführt
So, jetzt haben wir also uns mit Arrethmetischen Ausdrücken bisher beschäftigt,
in diesen arrethmetrischen Ausdrücken kommen Operatoren drin vor und wo Operatoren vorkommen.
Also es gibt keine Operatoren, ohne Operanten,
die sind also, was die Stelligkeit anbetrifft, immer mindestens einstellig.
Und das bedeutet, dass die Operanten auch einer bestimmten Wertemenge zugehörig sein müssen.
Ja, wenn wir jetzt Operatoren und Operanten nehmen,
dann sind wir da auf dem besten Wege,
um uns mit dem Typbegriff in objektorientierten Programmiersprachen näher auseinanderzusetzen.
Und das ist eine Auseinandersetzung,
die wird uns jetzt mindestens die nächsten zwei,
drei Vorlesungen,
wird sie
uns begleiten
Wir machen, wir fangen damit an,
dass wir diesen Typbegriff im Zusammenhang mit den sogenannten elementaren Datentypen besprechen,
diskutieren, hier auseinandernehmen und so dazu ist zunächst mal zu sagen,
also das ist so jetzt so, wie gesagt,
so unsere erste Begegnung damit.
Was legt der Typ in einer Programmiersprache fest? Das erste ist mal
die Wertemenge, die als zugehörig für diesen Typen definiert wird.
Bei Entager ist es also die, die in Zahlenraum,
der Programmiersprache, abbildbaren ganzen Zahlen.
Was soll ein Typ weiterhin festlegt, neben der Wertemenge?
Ist also die Art und Weise, wie die Elemente dieser Wertemenge,
wie mit denen umgegangen werden kann,
welche Operationen sind mit Operatoren auf den Elementen dieser Wertemenge möglich?
Bei den Typ Integer, also erst mal hat das Ding einen Namen,
es hat eine Wertemenge und man kann dann sagen,
wie kann ich die Elemente dieser Wertemenge manipulieren?
Bei dem Typ Integer sind die zulässigen Operationen halt Adian Subtrahieren,
multiplizieren und so weiter
Randbedingungen, dass immer nur Elemente dieser Wertemenge Ergebnisse von Operationen sein können,
die auf diesen Elementen der Wertemenge ausgeführt werden können.
Also vier geteilt durch drei, muss ein ganz zahliges Ergebnis haben.
Und deswegen erzeugt also das Ausführen dieser Operation auf ganzzahligen Werten.
Andere gehen ja nicht dann auch häufig über,
nicht häufig, aber dann mindestens einmal ein überraschendes Ergebnis.
Gucken wir uns gleich auch noch an. So,
jede Programmiersprache, jede höhere, sogenannte höhere Programmiersprache und Java
ist so ein Beispiel für eine höhere Programm,
bei mir Sprache, kommt mit einem Satz von elementaren Datentypen daher.
Der kann unterschiedlich sein. Was wir hier kennenlernen werden,
sind also elementare Datentypen für ganze Zahlen, reelle Zahlen für Zeichen,
womit wir uns noch etwas näher beschäftigen, sind die sogenannten Wahrheitswerte.
Dass das so ist, also dass genau das hier der Satz
elementarer Typen in einer Programmiersprache ist, ist in keiner Weise selbstverständlich.
Es gibt Programmiersprachen, also auch imperative Programmiersprachen der sogenannten dritten Generation,
in denen es zum Beispiel keine Wahrheitswerte gibt
Wird, also die Null, würde es denn so sein soll,
wird als False interpretiert, als Bullchar-Wert False und die Eins, der Integer 1 wird als Wahrheit, alle anderen Integer werden als Wahrheitswert war, True interpretiert. Das heißt,
man kann damit umgehen, also das ist diesen elementaren Datentyp nicht gibt,
in Java ist es, also wenn ich jetzt sage,
Gott sei Dank ist das also nicht nur ein falscher Zungenschlag,
man hat sich also bei den moderneren Programmiersprachen eigentlich bei allen gängigen Objektorientierten starke Typen,
statisch getypten Programmiersprachen darauf geeinigt,
dass das, was sie da sehen,
dass das der Minimalsatz von elementaren Datentypen ist Unser Ziel wird es sein,
wenn das so die Basismaschine ist, mit der wir umgehen können,
dass wir uns so schnell wie möglich von der Ebene dieser Basismaschine,
da wo es sinnvoll ist, verabschieden.
Und Buliens sind Buliens, also da braucht man nicht viel weiter drüber nachdenken.
Aber Fred hat ja auch schon so Beispiele gezeigt, wie,
warum ist es möglicherweise nicht sinnvoll, Eurobeträge als Intager abzubilden.
Oder warum ist es nicht sinnvoll, so etwas wie
eine Kundennummer als Intager abzubilden
Und das sind so die Fragen,
also mit denen wir uns beschäftigen müssen,
weil aus softwaretechnischer Perspektive wollen wir eigene Datentypen entwickeln,
die das ausdrücken, was man mit Elementen dieser Datentypen machen kann.
Und nicht das, was man mit den elementaren Datentypen machen kann,
mit denen man also in einer Programmiersprache standardmäßig konfrontiert wird.
Diese elementaren Datentypen bilden aber die Grundlage des Gerüst,
um dann solche komplexeren, selbst definierten Datentypen als Elemente dessen,
womit wir in Programmen umgehen können, abzubilden.
So, die alle elementaren Datentypen sind dadurch gekennzeichnet,
dass sie auch sogenannte literale zur Verfügung stellen, literale beinhalten.
Das sind die Elemente des Datentyps, die man einfach hinschreiben kann.
Das hat man ja auch gerne, dass man sowas wie 13 hinschreiben kann.
Und wenn das also ein Ausdruck ist, der einer Intager-Variable
zugegewiesen wird, dann hat diese Variable nachher den Wert 13.
Und dasselbe gilt zum Beispiel auch für Character,
also für einzelne Zeichen
Genau. Welche elementaren Datentypen gibt es dann also? Das ist jetzt wirklich
nur ein, nein, nicht nur, nicht wirklich.
Also das hier ist ein Ausschnitt, obwohl der schon,
glaube ich, ziemlich umfangreich ist, so als Ausschnitt. Nichtsdestotrotz steht hier,
also dieser in gelb gedruckte Hinweis, jemand,
der ein Faible für elementare Datentypen hat und dem das hier,
also was hier steht, auch als Information nicht genug ist,
dem sei, dass Java Referenzbuch empfehlen, empfohlen,
da gibt es also einen vollständigen Überblick über das,
was es an elementaren Datentypen in Java gibt und was man mit diesen Datentypen machen kann.
Insbesondere geht dieses Buch dann auch darauf ein,
was passiert, wenn man, also das,
was ich jetzt so für den Moment als Typ kompatibilität definiert habe,
nämlich Typ Gleichheit, wenn man diesen Grundsatz missachtet.
Also was wird in was eigentlich überführt,
wenn die Typen nicht gleich sind und welche Effekte entstehen dann,
wenn, also zum Beispiel eine Intager-Variable an einen Longwert zugewiesen wird.
Das ist, also da sollte man wissen,
was man tut
Und was man da, welche Effekte diese numerischen Typen bei Zuweisungen,
Werte von diesen Typen, welche Effekte das erzielt,
das wird dann eben Java-Referenzbuch, das in aller Ausführlichkeit beschrieben.
So, soviel, das waren jetzt so die elementaren Datentypen unter
besonderer Berücksichtigung von allem, was mir Zahlen zu tun hat.
Selbiges, so kann man jetzt für die Character machen. Also hier ist das das einzige,
was für sie nicht das einzige, aber sagen wir mal,
das, was häufiger, also gerade am Anfang für Sie als Programmieranfänger,
das ist ein klein wenig zu Verwirrung führend, ist,
dass man, wenn man eine 4 in Hochkommata hinschreibt und eine 4 auch ohne Hochkommata hinschreibt,
dass das für den Compiler eine unterschiedliche Bedeutung hat.
Wenn Sie die 4 so hinschreiben,
dann ist das der Character 4, also der Buchstabe 4,
während wenn Sie das ohne Hochkomma hinschreiben,
dann ist es die Zahl 4.
Das bedeutet einfach, was unterschiedlich ist. Mit dem Ding hier,
mit dem Integer, können Sie rechnen, damit können Sie andere Sachen machen.
Ich weiß doch nicht,
was kann man denn eigentlich mit einem Character alles machen,
außer dass man ihn vielleicht auf der Konsole ausgibt
Besonders viel. Man könnte ihn vielleicht noch an einen Streng dranhängen.
Das ist aber nicht etwas, was man mit einem Charakter machen kann.
Man könnte sich den Arsky-Code dieses Characters ausgeben lassen.
Das wäre nochmal eine interessante Übung. Naja, was man
halt so interessant findet. Also, das sind so,
man sollte für den Moment hier einfach festhalten, in so einer statisch getypten,
starken Typenprogrammiersprache wie Java, macht es einen Unterschied.
Mit dem Ding hier können sie nicht mehr rechnen,
ohne dass sie nicht gewaltige Verrenkungen innerhalb innerhalb ihres Programms anstellen.
So, jetzt habe ich schon den Begriff Asky in den Mund genommen.
Asky, wofür steht das denn? Nicht,
dass wir, jedenfalls nicht, dass ich wüsste,
auch wenn ich die einzelnen Prüfungsfragen in der Klausur nicht kenne,
aber ich glaube, es wird sich niemand ernsthaft danach fragen,
wofür das Akronym Asky steht.
Schaden tut es trotzdem nicht, wenn man weiß,
dass es Americans ended Code for Information Interchange bedeutet,
das ist so die, sagen wir mal,
der Klassiker unter den Kodierungen für Zeichensätze,
Also eine Art von Kodierung, die ziemlich lange,
ziemlich weit verbreitet ist.
Und ich zeige diese Folie mit dieser Definition auch gerade besonders gerne,
weil die beinhaltet schon so eine gewisse virtuelle Staubschicht.
Also wir sind zwar ständig bemüht, die Folien aktuell zu halten,
aber ich werde einen Teufel tun. Also so häufig,
wie ich hoffentlich diese Folie noch zeigen kann,
einen weit verbreiteter, besonders auf Heimcomputern.
Wer hat heutzutage noch einen Heimcomputer? Ich meine, ich habe noch,
also als ich in ihrem Alter war und Informatik studiert habe,
da hat ein Hochschullehrer,
dessen Altersabstand zu mir wohl ungefähr so groß gewesen ist,
wie ihr Altersabstand zu mir.
Der hat sich auch geweigert von Browsern zu sprechen.
Der sagte immer, Stöberer. Die ersten paar Male hat
mich das noch verwirrt, weil dann sagt er,
dann schauen Sie das mal im Stöberer nach.
Was will der jetzt, bis mir das mal klar wurde.
Ja, naja, ich meine, auf Ihrer Seite,
Sie machen auch manchmal so hübsche Witze mit der englischen Sprache.
Ich habe mal eine Seminararbeit gelesen und wir hatten also über
Unter anderem über State-Machines gesprochen.
State-Machines, also vielleicht haben Sie das noch nicht in theoretische Informatik gelernt.
Das sind sogenannte Zustandsautomaten. Und der junge Mensch,
also hatte wohl an der Stelle, wo es um die Definition ging,
auch nicht so gut zugehört.
Jedenfalls habe ich in dem Papier, der sprach immer von Staatsmaschinen.
Was will er mir sagen? Also die Staatsmaschine, ja.
Ist mir das mal so in der Rückübersetzung klar wurde,
der redet jetzt von Zustandsautomaten. Also ich weiß nicht,
ob auf einem Heimcomputer bei Ihnen zu Hause noch der Asky-Code
verwendet wird
Wahrscheinlich nicht. Wahrscheinlich wird da auch schon der Unicode-Zeichensatz verwendet.
Und da ist also so dieses Relikt des Aski-Zeichensatzes,
das ist darin noch vorhanden, nämlich die ersten 128 von 65,
5, 3, 6 verschiedenen Zeichen.
Also es sind für den Aski-Code reserviert. Das sind jetzt mehr so,
ich weiß nicht, als was sie das betrachten, wissen,
von dem sie nicht wussten, dass sie es nicht haben wollen. Also der jedenfalls funktionieren,
Java-Programme, also unter Verwendung dieses Unicode-Zeichensatzes und man kann,
also die Unicode-Zeichen, auch in Java,
ich kam ja über Literale jetzt zu diesem Ausflug,
man kann auch Unicode-Zeichen in Java darstellen und das ist halt,
sie sehen die Syntax für die Literale des Unicodes,
sehen sie hier,
das ist also so ein Backslash-U und dann also deine vierstellige Hexer-Dezimaler-Code und dann kriegen sie so einzelne Zeichen des Uni-Codes ausgedruckt,
also ein Beispiel sehen sie hier auch noch.
So, ich habe schon davon gesprochen, dass also die
Operatoren erwarten dann eben auch ihre für sie definierten Operanten.
Manchmal verhalten sie sich nicht so, wie sie das möglicherweise erwarten.
Also wenn sie die ganz zahlige Division, die man in Java so hinschreibt,
wenn sie die ausführen, dann gibt das als Ergebnis drei,
fragt man sich auch kurz, was soll das?
Kurzes Nachrichten ergibt, ist halt drei Rest 2.
Also die ganz zahlige Division ist so definiert und will,
wo es einen Rest gibt, da muss es auch den Modulo-Operator geben.
Also 20 Modulo-6 ist eben der Rest. Das sind alles
so die Operatoren oder so eine Teilmenge der Operatoren,
die auf Integern in Java definiert ist.
So die letzten Minuten möchte ich jetzt nur noch mit den Bulschen-Werten verbringen.
Hier sehen Sie jetzt so den Übergang von den Integern zu den Buliens,
also den Wahrheitswerten, war oder falsch, wenn man so die,
das wird jetzt hier motiviert über Vergleiche von Integern,
so welche Operatoren stehen dafür zur Verfügung, also das hier liest sich als,
ist zwei größer als eins plus eins und offensichtlich ist es nicht so.
Zwei ist aber größer gleich, minus eins, ja,
das ist, das ist wohl so, was ist denn das?
Drei, minus eins. Und hier kommt jetzt, also schon,
ihr Wissen, können Sie Ihr Wissen anbringen über das,
was ich ganz am Anfang der Vorlesung gesagt habe, über Eigenschaften von Operatoren.
Hier wird nämlich nicht gefragt, ist zwei größer gleich drei,
das wäre ja falsch und falsch, minus eins,
was ergibt das, falls, also ohne Haar,
weil falsch,
minus eins schneidet offensichtlich den letzten Buchstaben ab und
es gibt dann ein String mit fünf Elementen
Das wäre eine mögliche Interpretation in einer nicht stark getypten Programmiersprache.
Oder auch zweimal zwei größere Eins, also zwei größere Eins,
was ist zweimal war, wo das wäre in der Rohrwälschensprachdefinition,
wer das doppelt war, mal eins, Doppel war, okay.
Der Witz ist, glaube ich, angekommen.
In Java ist die Präzedenz eine andere. Da wird nämlich,
da haben, glaube ich, die vergleichenden Operatoren,
haben die geringste Bindungskraft und deswegen wird das auch so interpretiert,
wie sie das aus der Schulmathematik,
wie sie das gewohnt sind
So, so viel Spaß kann man haben,
wenn man keine stark getypte Programmiersprache verwendet.
Und dieses JavaScript ist halt keine stark getypte, statische Programmiersprache,
sondern es ist eine dynamische, dynamisch getypte Programmiersprache.
Und sie haben das jetzt, die Effekte gesehen. Also sie,
wir produzieren ja für sie hier sowas wie so eine Sandbox oder wie
es in dem ersten Video war, so ein Kindergarten.
Und sie denken, alles ist gut.
Aber was sie lernen werden ist,
also wir bringen ihnen ja dann
auch Aktivsprachen wie JavaScript später
Weil das sind sehr scharfe, das sind sehr mächtige Werkzeuge.
Und man sollte wissen, was man tut.
Und wir bringen ihnen hier die ganzen Grundlagen bei,
dass sie dann hoffentlich auch verantwortungsvoll sowas wie JavaScript später einsetzen können.
Für den Moment stark getypte Programmiersprache, alles wie Watt plus eins,
minus eins, das geht alles nicht.
Wir bewegen uns hier in diesem stark getypten Kontext. So,
und sie dürfen auch nicht mit Buliens rechnen. So,
Bullsche-Werte, Wahrheitswerte, die Grundlagen dafür, denke ich,
sind gelegt, so ein paar Operatoren werden wir,
müssen wir uns noch anschauen, sind sie auch vorbereitet,
das mitzulesen, was Fred ihnen gleich aufschreiben wird.
Das Logische und das logische oder und die Verneinung. Das ist,
wir brauchen diese Ausdrücke, wir brauchen diese Operatoren,
Entschuldigung, um etwas komplexere Ausdrücke auch formulieren zu können.
Und insbesondere werden diese Bullschen Ausdrücke auch,
indem ihnen schon bekannten If-Statement, werden die verwendet.
Also hier an der Stelle, wo hinter dem,
also der in dem terrn näheren Operator, wie wir seit heute wissen,
an dieser Stelle sowohl ein Literal stehen kann.
Das ist ist vergleichsweise sinnlos. Also hier If True hinzuschreiben
oder If Falls. Also mindestens einen Operanten kann man sich
dann sparen. Das kann aber auch eben eine Bullshit,
einen Ausdruck stehen, der einen Bull liefert,
also derart hier einen Vergleich x-größer 100 oder auch eine Bullshit-Methode,
so wie das Ziel steht, eine Bullshit-Methode,
also eine Methode, die einen Bullshit-Wert liefert.
So, dann brauchen wir die Bullshit-Ausdrücke noch an einer Stelle
wie dieser, die Schleifen.
Damit werden wir uns dann in einer der nächsten Vorlesungen beschäftigen,
also die wieder bedingte Wiederholung von Anweisungsfolgen
Ohne Bullshit-Ausdrücke lassen sich solche höheren Statements oder etwas komplizierteres Statements der kleinen Programmierung eben auch nicht formulieren.
So, hier sehen Sie jetzt so verschiedene Beispiele dafür,
also wie diese Bullshen-Ausdrücke verwendet werden können.
Und das hier ist ja so ein Ausdruck,
so die lesen sich ja, die Quatsch,
das hier, ja, kann man machen, Bullshit-Variable,
je nachdem, welchen wer sie hat.
Hier wird eine Methode, die einen Buhl liefert,
aufgerufen und hier, so ist so etwas,
also was ich Also ohne mit der Wimper zu zirken,
Fred, zutrauen würde, hinzuschreiben.
Ich muss da dreimal hingucken, was das denn wohl hier liefern könnte.
Also, und mir wird es auch erst klar,
in dem Moment, wo ich lese, aha,
Game Over, ja, also, wo bin ich?
Wenn es eine Kohlekoalition,
wenn es eine Kollision gibt und du bist nicht unverwundbar.
Okay. Oder die Restzeit ist gleich null.
Das ist sozusagen die ganze Vorlesung in einer Zeile,
dann ist dieser Teil der Vorlesung
gleich vorbei
Okay, so, die Wahrheitstafeln für die Bullchen-Ausdrücke, Not-End und Ohr.
Ich glaube, wenn sie die noch nicht kennen,
das sollten sie, also ziemlich schnell,
ziemlich auswendig lernen, weil das muss man lesen können,
wie so eine Zeitung, in der viele große Buchstaben abgedruckt werden.
Das gehört so wirklich nicht zum Kleinen einmal eins,
das gehört zum Zählen bis zehn innerhalb der Softwareentwicklung
So, damit bin ich dann auch am Ende und jetzt kriegen sie Whatman,
Winkler und wird ihnen das Ganze nochmal in Java nahelegen.
Ich wünsche Ihnen wie immer am Mittwoch um 15 Uhr
ein schönes Wochenende und wir sehen uns nächsten Mittwoch.
Ihnen Altersfrischem hier. Und zwar wollte ich mal anfangen mit dem Thema Leitkummerzahlen.
Muss man immer aus, hier ist sehen. So,
also ich habe zwei kleine Tools ins Kommen gestellt.
Wo man hier so Ausdrücke eingeben kann. Vielleicht mache ich
erstmal was, was ein bisschen weniger verwirrend ist.
Kann uns beliebige Java-Ausdrücke hier eingeben. Ich kann zum Beispiel
fragen, ist 0,1 plus 0,2, gleich 0,3.
Könnte man ja denken, dass es so ist.
Und das Interessante an diesem Tool ist jetzt,
dass es im Gegensatz zu Blue J.A.,
das starte ich vielleicht auch nochmal ganz kurz.
Das Netz ist ganz sichtbar. Das Fenster ist nicht
ganz sichtbar. Okay, wurde mir da nicht gesagt,
ich kann hier irgendwas drücken.
Irgendwie, ich soll auf PC drücken oder so
Das sieht man jetzt alles, ja, oder?
Ich glaube ja. Aber da drüben noch nicht.
Mal gucken, ob das so drüben auch funktioniert.
Na, sieht man alles? Ja, ich glaube,
man sieht jetzt alles, oder? Also ihr kennt ja schon im Blu-ray
diese Direkteingabe und da kann ich auch so was eingeben,
wie ist null Koppel, wenn ich es kann?
0,1 plus 0,2 ist das gleich 0,3. Leider, leider,
sagt Blu-ray aber nur das Endergebnis. Er sagt mir nicht,
wie es darauf gekommen ist, dass da jetzt Falls bei rauskommt.
Und deswegen gibt es halt dieses Tool, wenn man da
solche Java-Ausdrücke eingibt, dann werden euch die Zwischenschritte angezeigt.
Er sagt euch also, wenn ihr den Double 0,1 und den Double
0,2 addiert, dann kommt da halt ungefähr 0,3 raus.
Ja, und dann wird quasi dieses 0,3,
was er hier ausgerechnet hat, was quasi dem entspricht,
wird dann verglichen mit diesem 0,3,
was intern im Rechner so aussieht.
Tja, und wie man sieht, ist das ja offensichtlich nicht dasselbe.
Dieser Wert ist ein bisschen zu groß und dieser Wert ist
ein bisschen zu klein und deswegen ist es nicht gleich.
Komische Zahlen irgendwie, oder
Okay, um jetzt nochmal zu verstehen, warum das
so merkwürdige Zahlen sind. Also ich habe diese ganzen komischen
Ziffern ja gar nicht eingegeben, sondern eigentlich doch nur 0,1.
Warum kommt da jetzt noch so ein Quatsch? Gibt es
dieses zweite Tool? Vielleicht, ich lasse das mal hier stehen.
Da wird jetzt gezeigt, wie ein Float dargestellt wird.
Ich hätte das auch für Doubles machen können.
Dann hätte ich doppelt so viele Bits gebraucht. Ich glaube,
für Float reicht es, um das Prinzip zu verstehen.
Also wenn man sich anschaut, wie ein Float im Rechner
eigentlich dargestellt ist, dann besteht er aus 32 Bits.
Das erste Bit, wenn ich das mal anklicke,
ist einfach das Vorzeichen mit. Die sind die Zahl negativ.
Also wenn hier eine Null steht, dann ist die Zahl positiv.
Und wenn dann da einsteht, ist sie negativ.
Das ist so die einfachste Form von Vorzeichen zu speichern in einer Zahl.
Na gut, wir beschränken uns jetzt mal auf positive Zahlen.
Dann haben wir hier acht Bit, die euch etwas darüber sagen,
in welcher Größenordnung diese Zahl sozusagen spielt.
Das ist, ihr würdet jetzt wahrscheinlich sagen,
Exponent und tatsächlich steht auch hier oben das Wort Exponent,
diese Zahl, die ihr unten seht, hat den Exponenten null.
Komischerweise stehen jetzt hier aber nicht acht Nullen.
Das versuchen wir gleich mal so ein bisschen spielerisch zu ergründen,
warum das nicht so ist. Ich versuche mal,
diese Zahl, die hier steht, um einen zu erhöhen,
dann erhöht sich auch der Exponent um einen.
Dann erhöhe ich nochmal um einen, erhöht sich auch
der Exponent um einen. Ihr seht also,
das ist, wenn ich das hier um eine höhe,
dann erhöht sich auch der Exponent
Und was bedeutet das, wenn der Exponent sich um einen erhöht?
Achtet mal darauf, was hier unten mit der Zahl passiert.
Die verdoppelt sich jedes Mal. Also es wird sozusagen
so interpretiert, zwei hoch Exponent. Okay. Ja,
und warum ist das jetzt der Exponent Null?
Das ist irgendwie komisch, ne? Vielleicht will man ja
noch kleiner werden. Ich versuche mal, noch kleiner zu werden.
Oh, schaut mal, der Exponent kann auch negativ sein.
Ich kann den Exponenten minus eins haben und zwei hoch minus eins ist eben eineinhalb.
Und zwei hoch minus zwei ist ein Viertel,
zwölf Minusereisen, acht, sechzehntel und so weiter.
Das ist also einfach nur ein kleiner mathematischer Trick
Ich fange irgendwo in der Mitte an bei 127,
definiere das als den Exponenten null.
Und wenn ich weiter nach oben gehe, habe ich positive Exponenten.
Und wenn ich weiter nach unten gehe, habe ich negative Exponenten.
Das ist einfach so ein kleiner mathematischer Trick.
Weil sonst wäre halt die Frage,
wie stelle ich denn jetzt hier einen negativen Exponenten dar?
Man verschiebt es einfach entsprechend um 127. Okay, wir können also
jetzt mithilfe dieses Exponenten quasi jede Zweierpotenz hier unten generieren.
Seht ihr das? Ich kann hier relativ hoch werden.
Sehr schön. Aber man will ja vielleicht nicht nur Zweierpotenzen haben,
sondern man will vielleicht die drei zum Beispiel,
wie könnte ich die denn generell?
Die drei ist ja zwischen der zwei und der vier
Ich fange mal mit der zwei an und versuche jetzt mal irgendwie die drei hinzukriegen.
Ich klicke hier einfach mal ein bisschen rum. Oh,
ich habe es schon geschafft. Das ist ja interessant.
Also wenn der Exponent eins ist, stehen hier sozusagen,
ja ist das sozusagen die Einerziffer und was glaubt ihr,
was passiert, wenn ich jetzt hier hinklicke?
Wenn das die Einerziffer ist und dass die Zweierziffer,
das ist ja zusammen drei,
was für eine Ziffer wird das denn wohl sein?
Was kommt denn in der Folge zwei, eins als nächstes logisch,
das könnt ihr jetzt zwei Antworten auf die Frage geben.
Soll ich es einfach mal ausprobieren? Einhalb? Ja,
genau, das wäre dann ein Viertel,
das wäre dann ein Achtel,
das wäre dann ein Sechzehntel und ich kann jetzt hier
immer weiterklicken
Ihr seht, wenn ich das für alle Bits mache,
kriege ich eine Zahl, die ziemlich nah an der Viertern ist.
Zack, zack, zack, näher werde ich also nicht
an die Vier kommen. Das ist sozusagen die Zahl,
die unmittelbar vor der Vier bei den Floats kommt.
Wenn ich da jetzt insgesamt nochmal versuche zur nächsten Zahl zu gehen,
dann wird sich da Experient ändern, zack.
Und dann bin ich tatsächlich bei der Vier. Ja,
müsste ich also immer bei jeder Zahl euch überlegen,
zwischen welchen beiden zwei Potenzen liegt diese Zahl?
Und dann nehmt ihr die kleinere von den Bahnen,
zwar Potenzen. Und da könnt ihr durch die restlichen Bits
halt euch an die Zahl rantasten, die ihr haben wollt.
Okay, 0,1. Wie kommen wir denn da jetzt mal ran?
Ich fange mal vielleicht So. 0,1 liegt auch zwischen 2-2er-Potenzen.
1,0 ist sicherlich zu groß, ich halte Bier das nochmal,
ist auch zu groß, ich halte Bier es nochmal,
ist immer noch zu groß, ich halbiere es nochmal,
ist immer noch zu groß, ich halte es nochmal.
Okay, also 0,1 liegt offenbar zwischen 0,062225 und 0,125.
Das kann, glaube ich, jeder nachvollziehen, oder?
Irgendwie zwischen diesen beiden 2 Potenzen liegt die 0,1. Das heißt,
ich muss jetzt mit der kleineren anfangen und jetzt kann ich einfach mal wild hier durch die Gegend klicken.
Okay, ich bin noch nicht drüber. Oh,
das war schon zu viel, dann nehme ich das Bit mal wieder weg.
Das ist auch zu viel. Okay, das funktioniert,
das funktioniert. Jetzt, das ist schon wieder zu viel,
das ist schon wieder zu viel, das geht.
Das ist schon wieder zu viel, das ist schon wieder
zu viel.
Sieht jemand
ein Muster
Es ist zu viel hier, die muss ich wieder anklicken,
das ist wieder zu viel, die muss ich anklicken.
Ja, das ist ja interessant. Also diese Zahlen 0,1,
die uns als Menschensohn einfach und natürlich vorkommt, scheint in Benär unendlich zu sein.
Wo immer zwei Einer und zwei Nuller hintereinander stehen und das hört nie auf.
Das ist ein periodischer Benärbuch diesem 0,1. Tja,
und jetzt müssen wir uns am Ende entscheiden,
wollen wir ein bisschen zu wenig haben,
ist das die Zahl, die wir haben wollen?
Oder wollen wir an dieser Stelle ein bisschen aufrunden?
Dann haben wir eben ein bisschen zu viel. Und die Zahl,
die man dann, die der Rechner tatsächlich nimmt, ist diese.
Und die sieht der Fehler, der hier eingeführt wird,
ist quasi an dieser Stelle 1,
1 zu 4 oder anderthalb zu viel sozusagen,
wenn man sich die nächsten Ziel von anschaut.
Und wenn ich hier eine Null hinschreibe,
dann fehlen hier sechs, das ist deutlich schlimmer.
Ihr seht, also die 0,1 gibt es nicht als Float
und als Double wird es sie auch nicht geben.
Das ist das Blöde, dass viele Zahlen,
die uns so einfach vorkommen, inbinär periodisch sind.
Und das ist eben der Grund,
warum ihr nicht irgendwie float und Double für Geldbeträge verwenden solltet,
weil Geldbeträge ja eine sehr dezimale Angelegenheit sind.
Ein Euro wird in zehn Centstücke aufgeteilt sozusagen und die
zehn Cent schon gewinnen nochmal in einzelnen Stücke aufgeteilt.
Das hat eben sehr mit der Zahl zehn
zu tun
Okay, gibt es dazu noch Fragen zu 0,1?
Ja. Man kannte jetzt ja hier und sechs Sachen,
sehr gut darstellen, kann man das dann überteilen,
sonst würde das einfach unseren hiermit einzelnen 10. Eins geteilt durch die Zähne.
Also es ist ja, dieses Format ist ja kein Bruch,
also du kannst dir nirgendwo sagen,
hier ist ein Zähler und hier ist ein Nenner.
Wenn das gehen würde, wäre es kein Problem,
aber so ist das nicht aufgebaut.
Das Float ist so aufgebaut, ich habe eine Zahl zwischen
eins und zwei und die multipliziere ich mit einer Zweierpotenz.
Anders funktioniert das nun mal nicht.
Du könntest dir eigene Datentypen in Java schreiben,
zum Beispiel Bruch
Das werden wir in der letzten Woche von SO2, glaube ich,
machen, wo es dann solche Ungenauigkeiten nicht mehr gibt.
Da gibt es dann andere Ungenauigkeiten. Okay. Weitere Fragen
? Gut. Dann wollte ich euch nochmal was zeigen.
Also wir fangen wieder mit der Eins an.
Die Zahl nach der Eins in Float ist diese hier.
Und zwischen der und der Eins gibt es keine anderen Zahlen.
Und ich werde jetzt einfach mal den Exponenten so lange nach oben schrauben.
Ich werde die Zahl jetzt immer weiter verdoppeln.
Bisschen interessanter Effekt eintritt. Ihr seht schon,
das wird da immer kürzer hinterm Komma
So. Und jetzt nehme ich die Eins wieder weg.
Diese Zahl ist die erste Float-Zahl. Wie definiere ich das
jetzt gut? Nach dieser Flow-Zahl kommen nur noch ganze Zahlen.
Wenn ich jetzt hier mal hochzähle, seht ihr,
dass da einfach immer einer draufkommt.
Also die Zahl, was ist das für eine Zahl?
8 Millionen? 8 Millionen, 3088.608,
1,5 zum Beispiel gibt es nicht in Float.
Wenn ich mir das ausrechnen lasse,
kommt da wieder, wird das sozusagen wieder notgedrungen abgerundet
Das ist irgendwie ganz witzig. Und wenn ich das
nochmal verdopple, haben wir diese tolle Zahl, zweihoch 24.
Da gibt es jetzt nicht mal mehr alle ganzen Zahlen.
Also wenn ich jetzt zum Nachfolger gehe, seht ihr,
dass da schon immer zwei übersprungen werden.
Also diese Zahl zum Beispiel mit 217 am Ende gibt es
nicht in Float. Der muss sich dann entscheiden,
ob er die 16 oder die 18 nimmt. Das heißt also,
wenn ihr einen Inteacher nehmt und den in einen Float umwandelt,
kann es passieren, dass da nicht dieselbe Zahl bei rauskommt.
Da müsst ihr ein bisschen drauf aufpassen. Okay,
dann wollte ich nochmal zurückkommen zu der Sache mit dem Wurzel ziehen,
falls jetzt keine Fragen von eurer Seite kommen
Ja. Ich kriege jetzt zum Beispiel Java, Salva,
Florian, bis gleich. Du weißt doch, der Kompala
. Du fragst, ob er das weiß oder wir,
das weiß ich, ich habe die Frage nicht richtig verstanden.
Wie er das weiß, dafür müsstest du dir ja angucken,
wie im Compiler die Literale quasi gepasst werden.
Das kann ich dir gerne mal zeigen.
Ich habe sowas auch schon mal gebaut. Ich muss das
ja auch bauen für dieses Tool. Aber das geht jetzt,
glaube ich, ein bisschen über den Stoff der ersten Wochen
Ja. Es ist aber nichts, was man extra berücksichtigen müsste.
Es passiert sozusagen von ganz alleine. Also ist die 0,1 Stars hier nicht gibt,
erfordert es keinen Extraaufwand, diese ungefähre 0,1 hinzubekommen.
Ich schreibe mir eine Mail, ich schicke dir das.
Okay, wo war ich stehen geblieben?
Wurzelberechnung. Genau. Wir hatten uns ja letzte Woche überlegt,
wie man mit diesem schönen Nährungsverfahren Wurzeln berechnen kann.
Und wir hatten dieses blöde Problem, dass wir geschätzt haben,
eins könnte ja die Wurzel sein.
Wenn man das macht, dann hat man für Zahlen,
die nah an der Eins dran sind, ganz gute Ergebnisse.
Also berechnen wir mal zum Beispiel Wurzel von,
weiß ich,
Ich habe jetzt da fünf Iterationen gemacht und das ist schon fast die richtige Zahl.
Das sieht sehr gut aus. Aber wenn ich jetzt zum Beispiel,
zum Beispiel diese Zahlen nehme, wobei ich weiß jetzt nicht,
was da die echte Wurzel ist,
vielleicht sollte ich lieber eine 10er-Prozent nehmen.
Weißt du, was 2,12 Uhr auswendig ist?
4096? Natürlich 4096, klar. Okay,
schau mal. Das ist irgendwie eine ganz andere Zahl.
Man bräuchte also bei größeren Zahlen deutlich mehr Iterationen.
Vielleicht machen wir das, wenn wir über Vorschleife reden,
mal in ein, zwei Wochen. Aber viel schöner wäre es ja,
wenn wir hier eine Zahl bestimmen könnten,
die schon in der richtigen Größenordnung der Wurzel ist.
Also nach dem Motto, wenn wir mit 2 hoch 24 anfangen,
wäre es doch cool,
ungefähr mit 2 hoch 12 anfangen zu raten
Okay. Dazu können wir uns mal ein paar Beispielquadratzahlen angucken
und einfach mal so ein kleines Protokoll führen,
dass uns klar wird, was Quadratwurzeln in Float,
wie die miteinander zusammenhängen.
Das mache ich ein bisschen kleiner. So. Also nehmen wir
doch erstmal zum Beispiel irgendwelche Zweierpotenzen, also nehmen wir erstmal die Eins.
Wie sieht diese Zahl hier aus bei der Eins?
Das ist ja 127. Warum? Weil der Exponent null ist
. Vielleicht sollte ich da irgendwelche Überschriften drüber.
Ich mache das mal über eine Zone da drunter.
Das ist der Exponent
Und das ist die sogenannte Karre-Arakteristik.
Das ist aber jetzt nicht wichtig, wie das heißt.
Okay, und die Zahlen ist eins. Okay. So,
und da sagen wir mal lieber, die Wurzel ist eins. So.
Und dann möchte ich mal gucken, von welcher Zahl
muss ich denn die Wurzel ziehen, damit das rauskommt?
Also ich will quasi diese Zweierpotenzen vielleicht,
vielleicht reicht das schon ein bisschen, ein, zwei Läufe,
fünf, auch machen wir euch bis 128.
So. Welche Exponenten haben die jeweils? Muss ich das jetzt
da oben eingeben oder wisst ihr das auswendig?
Zwei habe ich gehört. Drei, vier, ja.
Das wisst ihr ja seit Carol,
dass diese ersten 8-2-Potenzen so aussehen.
Und hat jemand schon diesen Zusammenhang herstellen können zwischen diesen beiden Zahlen,
dass er mir sagen kann, was dann hier jeweils reingehört?
Sechs Posierungen. Ja, also welche konkrete Zahl kommt jetzt
hier rein? Soll ich das einfach mal machen?
Welche Zahl ist das? Jo. Und dann? 129.
Das sieht ja fast aus, als hätte das ein System.
Okay. So, ne? Gut. Von welcher Zahl
ist denn eins
die Wurzel
Eins. Von welcher Zahl ist zweite Wurzel? Vier.
Wie geht's weiter? 16? 64. 256. 1024. Okay.
Gut, ich glaube, das wird wahrscheinlich rein,
wenn wir müssen für die ersten drei oder vier machen.
Dann seht ihr, glaube ich, das System.
Okay, welche Exponenten haben wir hier jeweils?
Das kann ich natürlich einfach übernehmen. Zwei, vier,
sechs, acht, zehn, 12, 14. Stimmt das?
Ja. Seht ihr irgendeinen interessanten Zusammenhang zwischen dieser Spalte und dieser Spalte,
wenn es darum geht, die Wurzel zu sehen.
Was passiert mit dem Exponenten, wenn ich die Wurzeln ziehe
Welche mathematische Funktion bildet die 14 auf die 7 ab und die 10 auf die 5?
Mal zwei. Halbieren. Wir müssen einfach nur halbieren.
Das ist ja interessant. Das heißt,
wenn wir wissen, welcher Exponent in der ursprünglichen Zahl ist,
dann müssen wir den Exponenten einfach nur halbieren.
Und schon sind wir im richtigen, man sagt Ballpark auf Englisch,
wie sagt man das denn auf Deutsch?
In der richtigen Größenordnung. Ja,
wenn wir das also irgendwie hinkriegen zu sagen,
wir schauen uns mal diese Bits an der Zahl,
von der wir die Wurzel ziehen wollen und halbieren den Exponenten
Gut, was ist denn hier die Charakteristik? 127. Ja,
das Blöde ist jetzt, ich kann nicht einfach nur die Charakteristik halbieren.
Sieht das jemand? Wenn ich jetzt einfach nur hergehe und die Zahl halbiere,
die hier steht, hier steht ja die Charakteristik,
da kommt ja völliger Unsinn bei raus.
Also zum Beispiel 107 durch 2 wäre ja nicht 127,
das wäre irgendwas anderes.
Oder zum Beispiel 141 durch 2 ist auch überhaupt nicht
134. Was macht ihr denn da? Sieht jemand irgendeine mathematische
Formel, die diese Spalte auf diese Spalte abbildet?
Was muss ich mit dieser Zahl machen, damit diese rauskommen?
Was muss ich mit dieser machen,
damit diese rauskommt und so weiter
Wir sind uns tatsächlich begleitet. Das wären die logische Variante
, genau. Geht das auch mit einer einzigen Operation?
Ja, mit einer exponentanen. Du willst den Exponenten abziehen?
Also der Vorschlag war ja zu sagen, der jetzt eben kam,
warte mal, ich kann ja hier sogar rechnen,
kann ich das nicht drüber machen.
Also du hast gesagt, ich nehme diese Zahl, ups, subtrahiere 10727.
Ich will nicht diese blöde komische Direktanlage hier haben.
So, so hast du gesagt. Dann hast du gesagt,
durch zwei Teilen und dann die 127 wieder drauf.
Okay, das wird wahrscheinlich funktionieren. Die Frage ist nur
, geht es nicht ein bisschen einfacher
Aber es funktioniert. Geht es einfacher? Ja. Man kann
einfach weiterkennen, miteinander agieren und dann einfach 25 Aktionen.
Beide Exponenten agieren, das ist ein bisschen schwierig,
weil ich weiß ja nur den einen am Anfang, ne?
Nee. Ja? Hm? Ich habe nichts verstanden.
Monolo. Hier mit dem Motorrad nichts zu tun.
Wir können es ja mal so machen.
Wenn ich jetzt ganz brutal durch zwei addieren würde,
würde ja nicht 127 rauskommen. Welche Zahl würde denn,
wenn ich sie durch zwei dividiere, wo würde dann 127 herauskommen?
Macht die Frage Sinn? Welche Zahl durch zwei ergibt 127
Das ist einfach nichts. 254, also genau 127 mehr.
Und wie ist es zum Beispiel hier? Welche Zahl,
wenn ich sie durch zwei deale, wie die Reagiert 130?
260, also 127 mehr. Sieht jetzt jemand die Regel?
Ich kann also einfach 127 drauf addieren. Und dann durch
zwei Teile. Das ist ein bisschen einfacher, finde ich.
Da habe ich nicht so viel zu programmieren.
Ich ziehe das hier einfach runter. Jo. Genau.
Okay. Sonst müsst ihr euch im stillen Kämmerlein davon überzeugen,
dass es funktioniert. Sehr gut. Das heißt also,
wenn ich auf diese Charakteristik 127 drauf addiere und anschließend durch zwei Teile,
habe ich schon eine Zahl,
die sehr nah an der Wurzel dran ist
Das will ich jetzt mal mit euch machen.
Gut. Wir machen das tatsächlich erst mal für Float,
weil das für Float ein bisschen einfacher ist als für Double.
Ich nenne die Funktion jetzt einfach mal. Guess root.
Okay. Wir tun an Float X sein. Und es soll
ein Float rauskommen, der so ungefähr die Wurzel ist.
Jetzt haben wir aber ein riesiges Problem. Wie komme ich
denn überhaupt an diese Bits ran? Nur als wenn ich
einen Float habe, was kann ich mit einem Float machen?
Ich kann zwar Plus und Minus und so machen,
aber wenn ich jetzt zum Beispiel 127 auf dem Float drauf agiere,
passiert ja was völlig anderes als jetzt hier 27 drauf zu addieren,
ne?
127. Ich muss also erst mal irgendwie an die Bits rankommen.
Wie macht man das? Da gibt es eben
einen kleinen Trick, das zeige ich euch mal
ganz kurz
Gibt's. So, wenn ich das mache, Entschuldigung,
das ist natürlich Unsinn, hier muss innen stehen.
Wenn ich das mache, schaut der Rechner quasi in seinem
Speicher nach, okay, hier stehen jetzt 32 Bit.
Ich dachte bis jetzt immer, das wäre ein Float.
Ich nehme die Bits jetzt einfach mal ein Tusa, als wäre es ein Int.
Man erinnert also überhaupt nichts an den Bits. Das heißt,
wenn ich jetzt zum Beispiel diese 8 nehmen würde,
dann würde er daraus eine Zahl machen, die irgendwie,
oh Gott, 2 hoch 30 plus 2 hoch irgendwie 25 oder so.
Also eine Zahl, die überhaupt nichts mit 8 zu tun hat,
aber ich habe jetzt die Bits in der Art und kann
was mit den Bits machen.
Dann habe ich als nächstes gesagt, ich würde gerne an dieser Stelle
127 drauf attieren. Wenn ich jetzt einfach nur sage,
A plus 127, dann würde dir hier drauf attieren,
die 127, das will ich ja nicht.
Ich will dir ja hier drauf attieren. Ich muss also irgendwie
die 127 an die richtige Stelle schieben, bevor ich hier drauf attiere.
Das zeige ich euch kurz, wie das geht.
Ich nehme die 127 und schiebe sie an die richtige Stelle.
Weil das hier sozusagen 23 Bits sind, die ich überspringen muss. Okay,
dann habe ich euch nämlich auch mal diesen Operator gezeigt,
den werdet ihr sonst nie wieder sehen in der SE1 und der steht auf der Zusammenfassungsfolie drauf.
Das fand ich ein bisschen schade. Ja,
ich würde aber der Ernst vorher nicht so.
Er steht auf der Folie drauf,
aber wir haben nie was damit gemacht ansonsten
Achso, gut, okay. Weiß ich ja nicht,
in welchen Vorlesungen er sonst so sitzt. Okay,
und jetzt muss ich das nur noch durch zwei teilen.
Wie mache ich das denn jetzt am geschicktesten?
Also ich habe hier irgendwie meine Bits,
die irgendeine Bedeutung haben und ich will jetzt eigentlich,
dass jedes Bit nur noch halb so viel wert ist wie vorher.
Da jemand in D-Flanne etwas fortgeschrittener. Wir müssen es verschieben
. Also, ich verschiebe das jetzt einfach mal.
Um einen nach rechts. Ich nehme alle meine Bits,
verschiebe sie um einen, wo ist jetzt rechts von euch aus gesehen?
Hier, oder? Genau. Dadurch wird also
dieses Bit landet dann quasi hier, dieses Landet hier,
dieses Landetier und so weiter.
Und interessanterweise verschieben sich auch diese ganzen Bits.
Wenn ihr mal ein bisschen drüber nachdenkt,
ist das
gar nicht schlimm
Weil wenn ich von einer Zahl,
die zwischen 1 und 2 liegt,
die Wurzel ziehen will, dann will ich ja auch,
dass diese Zahl ein bisschen kleiner wird.
Also ich glaube, das ist schon gar nicht so schlecht.
Okay, jetzt habe ich also eine Bit-Darstellung.
Jetzt muss ich daraus wieder einen Float machen. Also in
Bits to Float von C. Und das gebe ich mal zurück.
Und jetzt probieren wir mal, ob da halbwegs sinnvolle Ergebnisse bei rauskommen.
Jetzt muss ich hier wieder meine Schiebekünste walten lassen.
Ihr solltet ja den Code sehen, dass ihr das nachvollziehen könnt.
So, Guess Road. Okay. Nehmen wir doch mal
Ja, zum Beispiel, was wir vorhin hatten.
16, 7, 7, 7, 2, 1, 6.
Da hatten wir gesagt, eigentlich müsst ihr da so was rauskommen
wie 4096. Und vorher kam irgendwie völliger Unsinn raus.
35.000 irgendwas. Also 4096. Wenn es so ungefähr der Wert
wäre, wäre ich ja schon zufrieden.
Oh, das ist ja völliger Unsinn. Was haben wir
denn da gemacht? Was haben wir da denn falsch gemacht?
E-Hochminus, das ist ja eine viel zu kleine Zahl.
Ein bisschen mit dem Geschäft auch bereits,
das ist ja eine mit zwei kleiner.
Ja, nee, das ist aber kein Problem.
Ach, ich habe es gar nicht drauf attiert.
Ich habe es gar nicht drauf attiert, sehe ich gerade.
Ich habe es vergessen drauf zu überdehnen.
Ich habe es einfach nur so als Konstante dahin gemacht.
Das ist natürlich nicht
so sinnvoll
Okay, noch ein zweiter Versuch. Okay.
Ungefähr 496 ist jetzt die Hoffnung. Wow. Dankeschön,
dankeschön, ein, zwei Leute klatschen. Okay,
also ja, für zwei Potenzen funktioniert es tatsächlich perfekt,
weil wir das ja anhand der zwei Potenzen uns überlegt haben.
Wir gucken mal, wie das ist mit anderen Zahlen.
Nehmen wir mal zum Beispiel 81. Ist schon nicht schlecht,
ne? Also die ersten zwei Stellen in Stimmen schon.
Okay. Dann machen wir jetzt mal dasselbe für Double
Was ist der Unterschied zwischen Float und Double? Einfach die,
die genaue ich gerade, die Anzahl der Bits.
Also, dass wir den Kontrast sehen könnt.
Ich muss jetzt hier auch sagen, Double,
das heißt Double, dann ist es hier ein Long,
das ist alles ein bisschen mechanischer Arbeit gerade.
So, dann ist auch natürlich diese Zahl anders,
weil, ja, wie viel, ich glaube,
er hat da 92 Bits, ich hoffe,
ich irre mich nicht und auch diese Zahl ist ein bisschen anders.
Das sind jetzt irgendwelche Langweilen-Details,
die müsst ihr jetzt nicht unbedingt sofort verstehen.
Das ist einfach nur andere Zahlen. So,
dann muss das hier ein Double sein und das hier muss
auch wieder double sein.
Long Bits
Total. Okay. Und dann machen wir es einfach folgendes hier,
anstatt zu sagen, wir gehen mal davon aus,
dass eins die Wurzel ist,
nehmen wir mal lieber diesen schöneren Schätzwert, ja,
Guess Root von X. Oder machen wir vielleicht mal drei,
drei Iterationen, das wollen wir reichen.
Okay. Dann testen wir das auch nochmal.
81. Okay. Vielleicht auch noch zwei Vorschläge aus dem Publikum
, was soll ich noch testen?
Das kenne ich auf zehn Stellen
Mhm. Zwei Sterne, das ist natürlich. Hm.
Das ist ja komisch. Das ist ja sehr merkwürdig,
also funktioniert, was... Nein. Wir nehmen nochmal vielleicht
irgendwelche Quadratzahlen, ob es damit geht. Oh,
also es ist drei, vielleicht auch noch nicht gut genug.
Könnt ihr euch dann selber überlegen, dass man ein bisschen mehr oder weniger nennt.
Ich will da jetzt nicht zu viel Zahlen noch drauf verwenden.
Aber ich möchte, dass ihr einfach versteht,
diese Bits liegen tatsächlich so im Arbeitsspeicher.
Manchmal sagt die CPU, ach, das soll ein Float sein,
weil der Programmierer das mal so gesagt hat.
Und man kann eben mit, je nach Programmiersprache,
mit gewissen Mitteln schon, wenn du sagen, nein,
nein, nein, nein, nein.
Diese Bits will ich jetzt mal so eins zu eins als Int haben,
damit ich die durch die Gegend schieben kann und da bitweise
irgendwas drauf addieren kann oder irgendwas.
Und später schummel ich das dann wieder als Float runter
Das ist für solche Anwendungsfälle tatsächlich ganz witzig. Mehr will
ich in der Richtung aber jetzt eigentlich auch nicht machen.
Habt ihr dazu noch irgendwelche Fragen, die man schnell beantworten kann?
Okay, gut. Also keine Angst, ihr braucht niemals
von Hand Wurzel ziehen. Ihr wisst ja, in Java
gibt es das schon vorgefertigt. Das war jetzt nur so
ein bisschen um die Tiefen von Flows ein bisschen einsteigen zu können.
Gut, dann schließe ich das mal wieder alles.
Und dann wollte ich mal als nächstes mit euch reden über,
wo habe ich das Projekt?
Ich muss das öffnen. Über Boliens. Boliens sind so
ein Thema. Der einfachste Datentyp, den man
sich so vorstellen kann
Aber für Anfänger manchmal trotzdem sehr schwierig zu verstehen,
weil man eben denkt,
naja, ich kenne die Bullens ja aus Kerre,
da hat man die in seinem If oder in seinem Wire
und man kann das halt so ein bisschen verunten und verodern.
Und das war es eigentlich ja schon,
aber man schreibt das immer nur so als Bedingung hin.
Und ich wollte euch einfach zeigen,
dass man auch anders mit Bullens umgehen kann.
Das ist also einfach ein Projekt jetzt aus der Woche, genau.
Wir haben also hier für euch ein Projekt gemacht,
wo ihr Ampelschaltung programmieren sollt. Eine Ampel hat ja verschiedene
Phasen in der ersten Phase, leuchtet diese grüne Lampe.
In der nächsten Phase leuchtet die gelbe. Wenn es jetzt
noch weiter funktionieren würde, das ist noch nicht programmiert,
wurde als nächstes die rote leuchten und als viertes würde dann
die rote und die gelbe leuchten.
Und dann geht es wieder von vorn los.
Es gibt also vier Phasen, durch die so zyklisch durchgegangen
wird.
Und wie ist das jetzt intern gebaut?
Wie ist dieser Datentyp-Ampel gebaut, dass er immer weiß,
welche von diesen Lampen gerade leuchten sollen, um uns das mal anschauen?
Huch. Da. Wir haben jetzt,
ich glaube zum ersten Mal, Variablen vom Typ Bulien.
Ihr wisst, wenn ihr eine Variable vom Typ Int habt,
dann kann da eine von vier Milliarden verschiedenen Zahlen drinstehen.
Und eine Bulienvariable kann eben nur zwei verschiedene Werte annehmen.
Sie kann Schuh sein, sie kann false sein
Okay, wir haben jetzt also hier drei Vare gehabt und das heißt,
wir haben theoretisch acht verschiedene Konfigurationen, in denen die signen könnten.
Jede kann ja True Wood of Holt sein, nur vier von denen sind aber sinnvoll.
Gut. Schauen wir uns mal den Konstrukt an,
ihr wisst ja schon, Konstruktoren,
wir werden ja immer dann aufrufen,
wenn ich mir ein Exemplar dieser Klasse erzeuge und Konstrukturen sollten dafür sorgen,
dass die Felder auf einen sinnvollen Anfangszustand kommen.
Ich sage also, in diesem Fall, diese Variable sollen wird True haben.
Was ist dann mit den anderen beiden Variablen?
Haben die jetzt irgendwelche Zufallswerte oder haben sie denselben Wert wie
die dritte Variable oder haben sie gar keinen Wert?
Darf ich gar nichts mit denen machen? Weiß jemand von
euch noch die Sprachregeln, was mit Feldern passiert dich
nicht explizit initialisiere
Ja, das ist witzig. Man weiß bei Bulien nie,
was ist der Default wert? Also will man optimistisch oder pessimistisch sein?
Was glaubst du denn, was der Default wert ist,
wenn du dir so den Code anguckst, der ja hoffentlich sinnvoll sein soll?
False wahrscheinlich, ne? Also es macht ja keinen Sinn,
alle Lampen anzumachen. Das ist wahrscheinlich irgendein Fehlercode. Okay,
also ein Zustandsfeld, was ihr nicht explizit initialisiert vom Typ Bulien,
hat den Wert False,
irgendwie juckt es mir aber den Fingern jetzt trotzdem,
das hinzuschreiben, weil sonst denkt man irgendwie,
hat der Programmierer das jetzt irgendwie vergessen oder ist er faul?
Ich schreibe es mal lieber hin,
dass irgendwie das klar ist und man kann sich die Ampel
dann auch ein bisschen schöner vorstellen, alles klar,
aus, aus und an.
Das ist die grüne Phase,
das verstehe ich
Dann etwas, was ich seit über zehn Jahren immer wieder
sehe und wir wollen das jetzt so langsam versuchen,
so früh wie möglich immer auszumerzen.
Wir haben hier eine sondierende Methode,
die heißt leuchtet rot und sie soll eben in dem Fall,
wenn hier Falls gespeichert oder ich sag mal leben anders und wenn hier True drin gespeichert ist,
dann soll True zurückkommen aus der Methode.
Und wenn Fouls drin gespeichert ist, soll Fouls Haus kommen
aus der Methode. Das funktioniert so. Ich kann das
also tatsächlich machen oder wird der richtige Wert rauskommen.
Aber es ist irgendwie ziemlich kompliziert. Und ich werde das
jetzt in mehreren Schritten zeigen, wie man das vereinfachen kann.
Dazu gehe ich jetzt mal wieder in meinen Frapple
Und das funktioniert ja nicht nur für Gleitkommazahlen,
sondern hoffentlich für alle elementaren Datentypen in Java.
Und ich werde jetzt einfach mal ganz blöd versuchen,
mir zu überlegen, wie kann denn dieser Vergleich,
also das ist ja ein Vergleich, hier steht ein gleicher Zeichen,
hier ist ein Bulien, hier ist ein Bulien.
Das ist ein Vergleich, wo ein Ergebnis bei rauskommt.
Das ist so, als würde da stehen, irgendwie x-mal irgendwas oder so.
Das muss ausgerechnet werden. Und ich überlege mir jetzt einfach
mal, welche verschiedenen Ergebnisse können denn da rauskommen?
Also das könnte ja zum Beispiel sein,
dass die rote Leuchte leuchtet, dann würde hier quasi Falls stehen.
Dann würde also das IF Folgendes machen, er würde Falls
vergleichen mit True.
Schauen wir mal,
was da rauskommt
Was ist denn, weißt du, wenn man Falls mit True vergleicht?
Falls, Symboleon, True ist ein Bolien. Und wenn ich
die beiden mit dem Gleichgleichoperator vergleiche, dann ist das Ergebnis False.
Okay, False ist also nicht Gleich True.
Gut. Könnte aber auch sein, dass diese Variante,
wenn wir True beinhaltet, dann würde Java ja ausrechnen,
was kommt denn aus, wenn ich True gleich,
gleich True ausrechnen will, was kommt daraus?
Schauen wir mal nach. Es ist spannend,
ich muss schon unterscrollen. Seht ihr das? Wenn ich
True mit True vergleiche, kommt True raus.
Also sozusagen der linke Operant ist immer das Ergebnis,
was auch rauskommt. Das bedeutet, mit True zu vergleichen
, ändert nichts an dem Wert
Wenn ihr zum Beispiel sagt, was ist denn
42 mal 1? Da sieht man denselben Effekt,
die Multiplikation mit 1 ändert nichts an dem Wert.
Oder wenn ich zum Beispiel null addiere,
die Addition mit null ändert nichts an dem Wert.
Und das ist hier genauso, ein Vergleich mit True
ändert nichts an dem Wert. Deswegen ist er sinnlos.
Ihr braucht diesen Vergleich mit True nicht machen. Deswegen?
Jetzt ist es hier immer für die gelbe Leuchte dargestellt.
Kann man das eben ohne das gleich gleich True machen?
Ich frage einfach nur nach, liebes Java.
Rechne doch mal bitte aus,
also schau im Speicher nach
Welcher Wert steht in der Variable, gelb leuchtet?
Und wie ist das IF, dann, wie ist die Semantik des IFs?
Wie arbeitet das IF? Es sagt ja,
ich gehe in diesen Blog, falls hier True rauskam und
ich gehe in diesen Blog, falls hier Foles rauskamen.
Ihr müsst nicht hin, ihr müsst nicht diesen Vergleich mit True machen,
weil das IF das sozusagen schon von alleine macht.
Also stellt euch vor, ihr habt vielleicht irgendwo ein anderes Öf,
ich schummel das jetzt mal hier so rein,
das hat jetzt keinen tieferen Sinn.
Also ihr habt vielleicht schon mal gefragt, ist X kleiner 100?
Ihr könnt ja doch fragen, ist es wahr des X-Kleiners
als 100? Das würde gehen. Aber das wäre
irgendwie sinnlos. Und ich kann auch fragen,
ob das wahr ist und ob das war,
das kann ich auch fragen
Ändert nichts. Genauso, als wenn es
ständig mit eins multiplizieren würde oder null drauf verliert.
Also diesen Vergleich braucht man nicht. Sehr schön.
So würde man das aber trotzdem auch irgendwie nicht schreiben.
Also sieht jemand irgendwie, wie man das noch einfacher machen kann.
Wie sehe ich irgendjemand, den ich noch nie hatte,
weil das ist jetzt so einfach.
Jetzt gehen die Hände schon wieder runter, weil alle,
die schon mal was gesagt haben, melden sich jetzt nicht mehr.
Das ist natürlich auch blöd. Du, was sagst du?
Ich habe nichts verstanden. Du wurdest die ganze Funktion wegnehmen
Ja, das mit der Welt. Nochmal, was würdest
du schreiben? Ja, ja. Leuchtet der Effektion aufrufen,
würde ich einfach sagen. Ja, nee, also ich,
diese Kapstellung hier wegnehmen, wollen wir eigentlich ungern machen.
Also das würde ja bedeuten, ich muss diese Varianten in Public
machen und da kann ein Klient von außen Zuständen erzeugen, die sinnlos sind.
Zum Beispiel alle auf Folds setzen oder alle auf True setzen,
so, das will ich nicht.
Also diese Funktion soll es schon geben,
aber es soll irgendwie einfacher gehen, ja.
Man kann ja theoretisch eigentlich direkt sagen, Return-Game, Leute,
das heißt, du hier bist und wenn es war,
dann wird es gut gewartet,
wenn es
heute nicht gewartet wird
Genau, man kann den Bujen einfach direkt zurückgeben.
Ich sage, liebes Java, schau im Speicher nach,
welcher Bujen ist jetzt gerade in der Variable gespeichert.
Und was auch immer darin gespeichert ist,
das wird ja faul sein, oder True.
Das liefert bitte zurück. Warum soll man da eine Freiunterscheidung machen?
Das macht irgendwie keinen Sinn, oder? Könnt ihr einfach
so direkt zurückgeben. Und ich war völlig begeistert,
als ich das erste Mal verstanden habe,
dass man Buliens zurückgeben kann aus Methoden.
Da ist mein, wie sagt man, meint gleich blau,
sagt man, glaube ich, heutzutage.
Okay. Gut. Ja, wir haben noch ein bisschen
Zeit. Wir schauen uns noch mal ganz kurz an,
das Witzige an diesem Projekt ist, dass es hier verschiedene Ampeln gibt.
Es gibt ja auch noch eine Bimpel,
die zeige ich euch immer
Die sieht genauso aus und hat auch, oh.
Da ist noch nicht mal die erste Phase implementiert,
aber ihr seht, wenn ich viermal klicke, ist sie wieder grün.
Okay, das scheint es schon zu funktionieren.
Was ist mit der Zimpel? Da geht überhaupt nichts.
Okay, ich wollte euch das einmal zeigen. Die sehen zwar
grafisch recht ähnlich aus, sind aber völlig anders implementiert.
Zum Beispiel hier habe ich jetzt nicht mehr drei Bulien,
sondern nur noch einen einzigen Int. Ich merke mir,
also bin ich in Phase 0 in Phase 1 und Phase 2 in Phase 3.
Und das wird immer so im Kreis sozusagen durchgezählt.
Und da müsst ihr Jetzt nur noch implementieren, ja gut,
welche von den Lampen leuchtet denn jetzt abhängig von der Phase?
Zum Beispiel hier, das ist sehr interessant.
Ich sage hier dem Java-System, rechne bitte aus,
ob in der Variable Phase der Wert null gespeichert ist.
Da kommt Fall zurück oder es kommt schon zurück.
Einer von den beiden Werten wird zurückkommen.
Und das sollst du bitte zurückgeben. Programmieranfänger schaben hier normalerweise,
wenn die Phase null ist, dann gibt True zurück,
ansonsten gibt Fall zurück. Braucht man aber nicht.
Man kann das einfach ausrechnen lassen und zurückgeben. Ja,
das gibt so ein paar Stellen in diesem System,
wo man das ganz nett ausnutzen kann.
Okay. Gut
Dann überlege ich, ich glaube, ich wollte euch noch
ein bisschen Hilfestellung geben, zu einer Aufgabe.
Wir haben tatsächlich eine konkrete Aufgabe zu Gleitkommazahlen. Die ist aber
längst nicht so anspruchsvoll, wie das Wurzel ziehen, was wir gerade gemacht haben.
Wir entspannen uns jetzt noch mal ein bisschen mit Gleitkommazahlen.
Wir versuchen noch mal so ein paar Eigenschaften zu verstehen,
die für uns nützlich sind. Okay,
also wir hatten ja schon gesehen, dass es Zahlen gibt,
wenn ich versuche, die mir als Flow zu betrachten,
dass sie schon in einem Bereich von Flows sind,
wo es nicht mehr alle ganzen Zahlen gibt.
Und das netteste Beispiel finde ich immer dieses,
weil das kann man sich gut merken, eins,
zwei, drei, vier, 5, 6, 7,
8, 9. Wenn ihr jetzt ein F dahinter schreibt,
heißt es,
das war bitte ein Flowdliteral sein.
Der Compiler versteht, ah,
ihr wollt einen Flowd haben
Ja, und dann seht ihr, dass der Wert,
der jetzt tatsächlich genommen wird, leider ein anderer ist,
weil wir jetzt eben in einem Bereich sind,
wo es nicht mehr jeden Float gibt,
sondern ich glaube nur noch jeden achten,
wenn mich nicht alles täuscht.
Okay, wir nehmen jetzt mal diesen Wert zum Beispiel,
das ist ja exakt der Wert, da wird sich nichts ändern.
Und ich versuche jetzt einfach mal einen drauf zu addieren.
Ich hatte das vorhin schon an der Grafik erklärt,
ihr versucht es jetzt normal zu erklären, ein bisschen anders.
Ich nehme also diese Zahl, versuche einen drauf zu addieren, schauen wir, was passiert?
Passiert nichts. Normalerweise würde der Mensch jetzt sagen,
naja, da müsste doch 93 stehen,
aber der Computer muss sich jetzt entscheiden,
nehme ich die 92 oder die 100 oder 800,
je nachdem, wie man es sieht.
Ich hätte lieber sagen sollen, 792 oder 800 hat er gesagt,
na gut, die 792 ist deutlich näher dran.
Wie viel müsste ich daneben damit definitiv, damit er quasi auffordern müsste,
glaube ich, 5, 5-1 nehmen.
1, 2, 3, 4,
5. Versuche ich doch mal 5 Einsen darauf zu studieren,
dann müsste ich ja rüberkommen über diese Hürde.
Suchen wir das mal. Okay. Oh. Das ist ja
doof. Was haben wir denn hier gemacht? Ja gut
, er hat das eben von links nachher jetzt ausgewertet.
Wir haben ja gelernt, der Plus-Operator ist linksassoziativ,
das heißt, er wird erstmal ausrechnen,
dass sich hier nichts ändert an dem Ergebnis, weil er wieder abrunden muss.
Hier muss er auch wieder abrunden, hier muss er auch wieder abrunden.
Also wir kommen irgendwie nicht von dieser 92 weg,
das ist ja doof
Vielleicht klammern wir das einfach mal. Auf den Folien steht es so schön,
irgendwie A plus B plus C, ist egal,
wie man das klammert, das gilt leider nur für Intergered Division,
weil Float at Division, Adition.
Bei Float macht es einen Unterschied.
Schauen wir da mal ganz kurz. Guck mal,
ihr seht jetzt, er fängt erst mal an auszurechnen,
das, was ich in der Klammer geschrieben habe.
Er sagt also zum Beispiel euch, sagt er euch,
eins und eins ist zwei. Das ist doch schon mal beruhigend,
dass diese einfachen Gesetze offenbar auch im Computer funktionieren.
2 und 1 ist 3, 23 ist 4,
94 ist 5. Und jetzt sagt er euch,
792 plus 5 ist 800.
Das wollten wir doch haben, oder? Genau,
jetzt sind wir endlich rübergekommen.
Also es ist nicht irgendwie 97,
Okay, also, dann wollte ich noch eine andere Sache mit euch machen.
Die hatte Guido auch schon angesprochen, ne?
Vier Drittel. Vier Drittel braucht man oft in der Physik,
wenn man irgendwelche Volumen von irgendwelchen Kugeln oder so ausrechnen will.
Also wenn ihr vielleicht, schreibt ihr mal ein Programm,
wo ihr sowas braucht, vier Drittel PR-Quadrat oder irgendwas.
Welchen Wert hat denn vier Drittel? Überlegt das doch mal
kurz fünf Sekunden. 1,3 irgendwas, ne? 1,3 Periode
. Schauen wir. Eins. Okay. Also,
der linke Operant ist ein Int, das soll diese,
das ist jetzt keine Java-Syntax, das ist jetzt von meinem Tool,
er sagt euch nur mal, welcher Typ das ist.
Also vier ist ein Int, drei ist ein Int,
wenn du die durcheinander dividierst, kommt auch wieder ein Int
Der Programmierer interessiert sich offenbar dafür,
wie oft passt die drei ganz in die vier rein?
Naja, einmal. Ich kann sie nicht ein zweites Mal
reintun, dann wäre ich ja schon bei sechs.
Okay, wie ist das dann mit Rundung?
Das werde ich häufig gefragt. Also zum Beispiel,
was ist denn zwischen neun durch zehn?
Das ist ja schon so nah an der Eins,
dann müsste das dann nicht eigentlich eins sein.
Schauen wir das einmal ganz kurz. Nee. Also ich
stelle wieder die Frage, wie oft passt die Szenen in
die neun rein, die passt kein einziges Mal rein.
Auch nicht, wenn es nur ein bisschen mehr wäre,
wenn ich versuche, sie da reinzustopfen.
Okay. Gut. Ich überlege,
ob ich euch noch was zeigen muss,
damit ihr nicht überrascht seid
Genau, eine Sache wollte ich euch noch zeigen. Also,
es gibt ja durchaus Zahlen, die man als Float darstellen kann.
Also nehmen wir zum Beispiel 0,5. Haben wir sie hier?
Und wenn ich das F wegnehme, dann ist es ein Double.
Seht ihr das? Und es scheint ja so zu sein,
dass die Werte tatsächlich exakt dieselben sind. Das ist einfach so,
dass dann in dieser langen Liste von Bits,
die ich auf 1 oder 0 setzen kann,
da gibt es eben ungefähr doppelt so viele,
die ich auf 1 oder 0 setzen kann.
Aber die sind fast alle null.
Oder ich glaube sogar sind alle null. Das heißt,
wenn ich jetzt zum Beispiel die Frage stelle,
ob das der gleiche Wert ist, Was glaubt ihr, was da rauskommt?
Das sind ja zwei verschiedene Typen mit verschiedenen Genauigkeiten, ist ein Float,
0,5, das gleiche wie ein Double 0,5 oder sind das irgendwie andere Werte?
Oder ist es ein Typfehler, geht das gar nicht
oder wird das irgendwie automatisch konvertiert oder so, ja?
Ich lebe nicht mal aus dem Fetz der Japa, kompletiert,
das automatisch bleibt einfach, dass so passiert nichts, was es tun.
Das wollen wir raus, ich glaube das auch.
Sehr schön. Gut. Also sozusagen die zusätzliche Genauigkeit von Double nutzt in dem Fall nichts,
weil die zusätzlichen Genauigkeit Bits alle null sind, also da haben wir nichts von.
Wenn die jetzt aber mal eine andere Zahl nehmen,
eine, die nicht so schön einfach ist,
zum Beispiel die hier, Seht also hier,
hier entstehen irgendwo ab der siebten, achten Stelle irgendwo,
entstehen hier so Ungenauigkeiten.
Da sind die Ungenauigkeiten eben verschieden, je nachdem,
wie viel Präzision ihr habt. Weil einfach in einem Float
nur irgendwie sechsmal ungefähr diese Periode von 1100 reinpasst und bei Double
passt sie eben ungefähr ein bisschen mehr als doppelt so oft rein.
Dann ist der Fehler also klein. Das heißt,
wenn ich hier frage, ob die Werte gleich sind,
würde mir sagen, nein, das sind verschiedene Werte.
Ich meine, lieber Programmierte, du siehst doch wohl,
dass das ein anderer Wert ist als der.
Ja, schauen wir mal. Tatsache sind verschiedene Werte.
Ihr könnt euch sogar die Differenz berechnen lassen.
Dann seht ihr, was die Differenz der Differenzfehler
sozusagen ist
Gut, ich glaube, ich habe euch alles gezeigt,
was ihr für die Übung baut.
Eine Sache wollte ich schon noch zeigen, weil die immer
in der Klausur relevant ist und die Leute vergessen das bis dahin immer.
Guido hatte ja was über Zeichen erzählt. Ich wollte auch
noch mal ganz kurz ein, zwei Minuten was über Zeichen erzählen.
Also, man kann diese Zeichen so hinschreiben. Hier ist
es. Und wenn man sich jetzt die Frage stellt,
welchen Unicode oder Askri-Code hat das eigentlich,
dann gibt es einen ganz einfachen, oder es gibt mehrere Tricks.
Ich kann zum Beispiel sagen, ich will es in den Int umwandeln,
das schreibt man so. Man schreibt einfach davor,
in welchen Typen will ich es umwandeln, das sieht dann so aus,
das ist dann die 97. Oder was man auch machen kann,
man kann sagen, ich addiere einfach mal null drauf.
Dann wird der Compiler sagen, Moment mal,
ein Schar und ein Int zu addieren, ist ja Quatsch,
dann wandle ich mal den Schar vorher implizit in den Int um,
nämlich in die 97 und addiere dann nichts
Das geht genauso. Und was ihr auch machen könnt,
dann trägt der, der nicht so häufig bekannt ist.
Ihr sagt einfach, ich will Plus A haben.
Plus A ist dasselbe wie ein 0 plus A. Das geht also auch.
Also wenn ihr als Informatiker wisst, dass A,
die Unicorn 97 hat, dann seid ihr schon ziemlich gut.
Dann seid ihr hoffentlich nicht so verwirrt in der Klausur.
Und man kann zum Beispiel auch Charles Subter hier. Dann sagt der Compiler,
Moment mal, das macht ja bei Charles eigentlich keinen Sinn,
dann wandle ich den Z erstmal in sein Unicorn-Ind um,
bei dem A genauso.
Und dann gucke ich, wie weit sie voneinander weg sind.
Selbst wenn ihr jetzt nicht wisst, welche Wertezeit und A
hätten, wie weit sind die denn voneinander weg?
Die folgen ja im Code direkt hintereinander. Also ob die
jetzt immer bei 97 starten oder bei 100 oder bei 1000
, ist ja eigentlich egal.
Wie groß ist der Abstand zwischen A und Z
23, 25, 26. 25. Aber es gibt auch
26 Buchstaben, das ist ja komisch. Kann mir einer
auch noch zum Abschluss erkennen, warum hier nicht 26 rauskommt?
Ja. Das hat damit nichts zu tun.
Es ist egal, wo man anfängt zu ziehen.
Also wenn ich zum Beispiel sage, A,
ist der erste Buchstabe und Z der 26. kommt ja auch 25 raus.
Jetzt habe ich es eigentlich schon verraten, oder?
26 minus 1 ist 25. Okay, ich glaube,
es sind keine Fragen mehr.
Ich entlasse euch für heute.
Vielen Dank