du halt Vorlesung 7. In der Hoffnung,
die er bekanntlich zuletzt stirbt,
dass ich Ihnen heute was über strukturierte Programmierung und ich werde mit Blick auf diese E-Mail,
werde ich mal noch so auf so ein paar Sachen eingehen,
von denen ich eigentlich dachte, oh,
jetzt kannst du denen nicht nochmal erzählen, oder?
Das ist doch alt. Aber ja, natürlich, du
es halt nochmal. Heute geht es um zwei Themen,
sagen wir mal, anderthalb Themen,
strukturierte Programmierung
Wir werden nochmal so ein paar Konstrukte, die wir bereits kennengelernt haben,
als Elemente der strukturierten Programmierung werden wir wiederholen.
Andere, das werden wir gleichzeitig, da hat es auch noch einen vertiefenden Aspekt.
Und es hat auch einen Aspekt von dem,
was ich gerade gesagt habe, nämlich Variablen, Deklaration,
Verwendung von Variablen.
Wann kann man was tun? Welche Effekte erzielen sie durch
die Deklaration von Variablen? Und wir werden noch so das
ein oder andere, die eine oder andere
Kontrollstruktur kennenlernen
So, strukturierte Programmierung, so das, was sie ja, vermute ich jedenfalls, nehme ich an.
Ich frage lieber gar nicht erst nach. Das,
was sie so auswendig vor sich hin sagen können,
welche Kontrollstrukturen gibt es in der strukturierten Programmierung, da stehen sie nochmal Sequenzauswahl und Wiederholung.
Sie haben das in Carol,
haben sie das ja schon so ansatzweise kennengelernt heute,
werden wir so noch, werden wir da einen Deckel drauf machen,
indem sie so die ganze Vielfalt der Ausprägungen von Kontrollstrukturen insbesondere zur Auswahl und zur Wiederholung kennenlernen werden und ansatzweise in diesem Teil der Vorlesung,
was das, wie das konzeptionell gehandhabt werden kann und im zweiten Teil der Vorlesung,
wie immer, wie das dann in Java,
en detail realisiert ist.
So, hier ist, ja, Punkt dazu. So,
wir müssen jetzt einen Schritt, müssen wir noch zurückgehen,
bevor wir dann, also zu diesen besagten Kontrollstrukturen kommen und das sind die sogenannten zusammengesetzten Anweisungen.
Das ist so eine Art von Kontrollstruktur,
die so nicht ein eigenes Leben führt,
aber so eine Art von Kontrollstruktur, die man in anderen Kontrollstrukturen verwenden kann.
Ich wollte ihn jetzt mal so kurz so auch im Zusammenhang
mit der Fallunterscheidung und der Wiederholung zeigen,
also welche Bedeutung das hat und wie sinnvoll das ist,
sich mit zusammengesetzten Anweisungen auseinanderzusetzen. Zusammengesetzte Anweisungen sind also,
der Name deutet es nicht nur an,
der Name ist da eigentlich schon so sinnstiftend,
so was sie hier sehen, ist also in der Programmiersprache Allgäu 60,
ich hatte da schon mal glaube ich drüber gesprochen,
so die erste strukturierte Programmiersprache, die hatte genau sowas wie zusammengesetzte Anweisungen.
Und die Idee ist, dass ein solcher Block,
der durch eine zusammengesetzte Anweisung definiert wird, dass der,
also nicht, den kann man syntaktisch erkennen,
das ist also durch einen Beginn und ein Endstatement,
also in dieser Programmiersprache, Allgäu 60 und dazwischen stehen einfache Anweisungen, also Englisch Statements.
So, das kann man jetzt erstmal sagen,
ja gut, also wenn das da so steht,
also ist das vielleicht nicht nur vielleicht,
das ist also wahrscheinlich noch nicht wirklich erkennbar, worin der nutzen,
also eine dass es bei der solchen zusammengesetzten Anweisung besteht.
Ich hoffe, das wird etwas deutlicher,
wenn man sich mal jetzt, also so dieses Stück Programm-Code anschaut,
also dass sie von seiner syntaktischen Struktur her wahrscheinlich viel besser erkennen können.
Das ist nämlich schon Java-Code. Und möglicherweise haben sie sich schon gefragt,
also viele von Ihnen auch die Frage schon beantwortet,
was ist mit diesem geschweiften Klammern so auf sich hat?
Die geschweiften Klammern sind, die kurz schreibweise für das,
was in Allgäu 60 als Beginn und End bezeichnet wurde,
eben der Anfang eines Blockes und das Ende eines Blockes und dazwischen die Anweisung werden also immer zusammen ausgeführt.
Weil man könnte sich ja jetzt, wenn man da mal drauf schaut,
könnte man sich ja fragen, also nun ja,
also wenn A, kleiner als B ist,
wie viele Anweisungen hinter diesem, hinter dieser Bulschen,
hinter diesem Bulschen Statement, wie viele werden denn da überhaupt ausgeführt?
Und wenn das also ohne Klammern hier stehen würde,
dann würde ein ausschließlich die Deklaration dieser Variablen Mal abgesehen davon,
dass das also wahrscheinlich zu einem anderen Fehler führen würde.
Aber die Bedeutung dieses Statements, so wie es jetzt da steht,
ist, also dieses If-Statements ist,
wenn also diese Bedingung hier zu True evaluiert,
dann wird diese zusammengesetzte Anweisung insgesamt ausgeführt.
Okay. So, das ist also ein Verwendungszweck für zusammengesetzte Anweisungen.
Und Sie sehen hier auch schon gleich einen weiteren Zweck für
zusammengesetzte Anweisungen, diese zusammengesetzten Anweisungen,
deklarieren, schaffen einen eigenen Sicht,
sogenannten Sichtbarkeitsbereich
Indem sie hier, wie das steht, sodass jetzt die nächste Art,
das ist auch die letzte Art von Variablen, die wir kennenlernen.
Eine Block, lokale Variable verwenden können, eine Variable,
die ausschließlich innerhalb des Deklarierenden Blocks sichtbar ist,
ausschließlich innerhalb dieses deklarierenden Blocks verwendet werden kann.
Dass das total sinnvoll ist, solche Block-lokalen Variablen zu deklarieren,
ist hoffentlich an dem Beispiel wird es klar.
Also so ein Swap zwischen A und B werde ich,
ohne dass ich eine lokale Variable deklarieren kann,
also eine Block-lokale Variable deklarieren kann
Kann das zwar hinkriegen, indem ich also mich zum Beispiel auf eine Exemplarvariable beziehe.
Das will man aber nicht. So, jetzt sagen sie,
wieso will man das nicht? So kann ich doch machen, oder? Also in der Klasse,
in der also diese Operation aufgerufen wird,
kann ich irgendwo eine Variable Tamp deklarieren und ich weiß jetzt sogar nach der letzten Vorlesung,
also wie ich das in einem UML-Diagramm, wie ich eine solche Variable,
so syntaktisch korrekt in so einem Diagramm fasse.
Der Punkt ist, Ich möchte die Verwendung von Variablen und deren Deklaration, so Nahe wie möglich beieinander haben. Das nützt mir,
also wenn ich jetzt dieses Stück Code verstehen möchte,
was hier steht, sagen wir mal,
das ist jetzt intellektuell nicht besonders aufwendig,
aber es gibt ja auch Code-Zeilen, die durchaus,
also so eine Herausforderung darstellen, dann will ich die Variablen,
die daran beteiligt sind, die will ich also auf einen Blick,
möchte ich erkennen können, was damit los ist und das nützt mir,
also dann in dem Moment irgendwann mal die Klasse hat,
so 100,
150 Zeiten
Wenn ich hier also diesen Deklarationsteil, wenn ich den woanders habe,
dann bin ich, wenn ich nicht,
also ein ziemlich gutes Gedächtnis habe, bin ich gezwungen mal,
also so von mir aus an den Anfang der Klasse zu scrollen oder mit den Mitteln,
also der Programmierumgebung.
Sie kennen noch nicht so umfassendere Programmierumgebung, aber mir anzuschreiben,
wo ist das Ding eigentlich deklariert und wird es möglicherweise
auch noch an anderen Stellen von jemand anders benutzt,
kann ich das an der Stelle einfach überschreiben.
Außerdem einen anderen Wert zuweisen. All diese Fragen brauchen sie
sich nicht zu stellen, wenn sie Block,
lokale Variablen oder überhaupt lokale Variablen in Prozeduren, Funktionen verwenden.
Wenn also die Deklaration der Variablen und ihre Verwendung
möglichst nah beieinander geschehen
Also, das zum Thema zusammengesetzte Anweisung.
Jetzt kommen wir noch mal kurz zurück zur Fallunterscheidung.
Was ist da also mit Blöcken so auf sich hat?
Sie sehen hier die allgemeine Form der IF-Anweisung, der Fallunterscheidung,
diese von der Operator-Sprechweise, also diese Triadische Operation,
so die kann man ja dann,
also das hier ist die allgemeine Form, hier sehen Sie ein Beispiel.
Und hier sehen Sie jetzt eine Verwendung von einer Verwendung,
ohne dass Blöcke verwendet werden
So, das ist unkritisch an der Stelle,
weil hier jeweils hinter dem, weil hier nur eine Anweisung steht,
sowohl was den Zen-Teil anbetrifft, als auch was den Els-Teil anbetrifft.
Das ist aber ein Sonderfall. Das wird man so in der freien Wildbahn,
wird man diese Anweisung in der Form so nicht finden.
Das ist immer, wenn nicht immer, aber der Regelfall ist eher,
dass man da aufgrund einer Fallunterscheidung mehrere Anweisungen durchführen möchte.
Sondern kann das also so unterschiedlich aussehen. Und jetzt machen sie sich einfach mal,
es gibt da nach meinem Kenntnisstand,
gibt es Also keine wirklich belastbaren empirischen Untersuchungen,
aber es dürfte wohl so sein, dass Code,
sag mal so aus dem Bauch rausgeschätzt,
zu 90 Prozent der Zeit wird Code gelesen.
Nur zu deinen 11 Prozent bleiben noch über. Also so zum
weitaus geringeren Prozent, Prozent Prozentzahl der Zeit wird Code geschrieben.
So und jetzt kommen sie also morgens ins Büro,
machen nicht die Zeitung auf,
sondern machen also den Editor auf oder sehen sie das hier
Und jetzt, also sagen wir mal, wenn ich das
hier als erstes lesen würde, hätte ich gleich schlechte Laune.
Ja. Das ist so, ja, so,
Punkt. Warum erzeugt das hier bei mir schlechte Laune?
Ich muss mich beim Lesen dieses Codes anstrengen.
Ich muss nämlich rausfinden, was steht da eigentlich?
Will er mich veräppeln mit dir, der mit dem Eindrücken?
So, was bedeutet das denn jetzt? Welcher Code wird
denn jetzt eigentlich ausgeführt, wenn Summe gleich null ist?
Und wenn dieser Account gleich null ist und in den beiden anderen Fällen,
die da ausgedrückt sind, Genau so sieht es aus.
Also sagen wir mal, es ist schon ein bisschen besser.
Also was jetzt die tatsächlichen Effekte dieser Anweisung anbetrifft.
Hier steht ja dieselbe Anweisung wie oben, bloß das liest sich schon,
ich will nicht sagen ganz anders, aber das liest sich schon augenfreundlicher.
Sie sehen, was die Beispiele 1 und 2, also was die,
also wie das zu interpretieren ist, sehen Sie hier.
Wenn ich das hier als erstes aufschlage, ich will nicht behaupten,
dass das bei mir jetzt also gute Laune erzeugt,
es lässt mich jedenfalls neutral zurück,
weil hier sehe ich Oh, das Leben kann schön sein.
Also hier ist eine bulsche Abfrage, die verstehe ich.
Das ist der Sen-Teil. Das ist nämlich ein Block,
der hier eröffnet wird. Okay, und im Sen-Teil
gibt es also ein weiteres If-Statement und da steht das.
So, das verstehe ich doch jetzt. Also wenn das und das
der Fall ist, dann ist das das Ergebnis. Ansonsten,
und jetzt sehe ich das nämlich gleich auf den ersten Blick,
dieses Els bezieht sich gar nicht auf dieses If,
sondern das bezieht sich auf dieses If hier.
Und das möchte ich
sehen können
Ich möchte nicht, also ich will keinen Augenschmerz haben,
ich will keinen Magengeschwür kriegen, wenn ich Code lese,
sondern ich möchte sehen, aha, das ist das,
was der Autor mir sagen möchte.
Das ist wie früher, ich weiß nicht,
bei wem ich jetzt Magengeschwüre traumatische Erinnerungen hervorrufe.
Kurze Sätze, starke Werben, klare Gedanken.
Das hat ihn hoffentlich im Deutschunterricht mal jemand beigebracht.
Und Software sind Texte, will ich sagen, kurz,
also das muss man natürlich jetzt im Rahmen von Coach schreiben,
muss man diese drei Anweisungen,
die ich gerade gesagt habe,
muss man die
auch interpretieren
Das hier, wenn es so Stilnoten gäbe für das Schreiben von Code,
das hier kriegt so eine 5,9 Punkte,
auf der nach, ich glaube,
sechs Punkte kann man Maxi gerade mal kriegen beim Eiskunstlauf.
Und das hier kriegt also 0,5 oder 0,3 irgendwas,
so was von der kannte.
So, jetzt habe ich über Blöcke gesprochen und also
wie Blöcke in der geschachtelten Fallunterscheidung verwendet werden können.
Und jetzt gucken Sie sich nochmal kurz das hier an
Sie werden über kurz oder lang, da können sie sich
überhaupt nicht gegen wehren, werden sie so Muster entwickeln.
Und diese Muster entwickeln sie,
weil sie sich daran gewöhnen, Kaut zu lesen.
Und ein Muster, das sie wahrscheinlich häufiger entdecken werden können,
ist das sogenannte Sägezahnmuster.
If then if than if then if then
Els. Irgendwas ist ja schief. Okay, ich komme
nicht wieder. Ich weiß nicht. Das ist jetzt,
das ist jetzt Modellbildung, was bei mir stattfindet.
Und diese Modellbildung hat wahrscheinlich nichts mit den physikalischen,
technischen Grundlagen dessen zu tun, was hier passiert.
Aber ich gehe da jetzt einfach nicht mehr hin.
Mal gucken, ob es hilft. So,
das da ist das Sägezahnmuster, das sie häufiger entdecken werden.
Und dann sehen sie schon, ach guck mal da,
da will also jemand eine mächtige Fallunterscheidung machen,
bevor irgendwas in dem letzten Van-Teil,
da passiert es dann wirklich
Und vor, und wenn, also irgendwas anderes vorher schief gelaufen ist,
also dass der jeweils Korrespondierende Els-Teil, dann will ich immer genau ablesen können,
an welcher Stelle ist es denn jetzt eigentlich schief gegangen,
sodass ich also so,
es sollen sich so Muster bei ihnen schon durch Bloßes draufschauen auf den Code
, sollen sich schon so, sagen wir mal,
soll sich der Blutdruck um so zehn Punkte verringern,
damit sie sehen, ah, da hat jemand,
also strukturiert über ein Problem nachgedacht und hat es für bald,
es war schon mal mindestens in der Lage,
das strukturiert aufzuschreiben
So können sie dann, also geschachtelte, also auch tief ineinander geschachtelte IF-Anweisung,
also ich will nicht sagen benutzerfreundlich, aber doch menschenfreundlich formulieren.
So, jetzt irgendwann kommt dann der Zeitpunkt, wo Sie sagen,
also möglicherweise sind diese Sägezahnartigen Strukturen nicht das, also geeignete Ausdrucksmittel, um eine Auswahl vorzunehmen.
Dazu hat eben, gibt es noch so eine andere Art,
also wenn das Problem, aus dem Sie auswählen,
eine Alternative auswählen wollen, wenn das Problem so geschaltet gestaltet ist,
dass also die nicht, also nacheinander etwas überprüft wird,
sondern dass gleichzeitig verschiedene Alternativen, sagen wir lieber Möglichkeiten,
verschiedene Möglichkeiten existieren, dann können sie auch die Switch-Anweisung verwenden.
Die sieht, sagen wir mal, hinreichend ähnlich aus,
also sieht so ähnlich aus wie die IF-Anweisung. Hier steht halt nicht IF,
sondern Switch und dann wird zwischen einer Expression,
und das ist eben keine Bullshare Expression, Expression,
sondern das kann also ein Charakter sein oder ein Intager,
also irgendetwas, was man eindeutet, nicht irgendetwas,
mal für den Moment etwas,
was man eindeutig bestimmen kann von seinem Wert her.
Dann sagt man, naja gut, wenn es diesen Wert,
also ich werte diese Expression aus und je nachdem,
wenn es also wert eins ist, dann wird folgendes Statement ausgeführt.
Dank folgendes Date. Nenne ich dann,
das sind jetzt schon die Details, die Frage,
die ich jetzt hier schon von meinem geistigen Auge auswerte,
ist, wenn diese Expression ergibt, dass,
also sie zu Value 1 evaluiert ausgewertet wird, dann,
genau dann, werden dieses Statements hier durchgeführt.
Nämlich die, die hinter Statements 1 steht. Stellt sich sofort für den,
das ist wie so ein Pufflow Shareflex,
stellt sich sofort für den Programmierer die Frage, ja,
und dann, was passiert dann?
Und was dann in Java passiert ist, solange mir niemand
was anderes sagt, dann mache ich hier weiter bei Statements 2.
Was typischerweise nicht typischerweise, aber sagen wir mal so,
wenn man sich schon die Mühe macht zwischen Value 1 und Value
2 zu unterscheiden, liegt es häufig nahe,
dass das als entweder oder interpretiert wird
Und wenn dann also hinter Statement 1 Statements 1 einfach weitergemacht wird,
dann ist das nicht entweder oder,
sondern dann ist das sowohl als auch,
was was anderes ist, als entweder oder.
Wenn sie entweder oder ausdrücken wollen, dann müssen sie noch
das hier sagen. Also sagen wir mal,
diese Expression hier wird zu Value 2 evaluiert, dann führe die Anweisung,
diese Anweisungen durch und danach heißt es Gummi e-Break.
Also wir unterbrechen das hier und dann wird,
also hinter dieses Switch-Statement gesprungen. Das sind so die Feinheiten,
das kann man alles mal Ich denke,
da nimmt man sich einfach mal so zwei,
drei Stunden am späten Abend und also programmiert die unterschiedlichen Fälle aus.
Das ist alles kein Geheimnis. Das ist kein Magic.
Das sollte man einfach so als Handwerkszeug zur Verwendung,
dieses Switch-Statement, sollte man das mal ausprobiert haben.
Und wenn man das also so verstanden hat,
dann machen sie ruhig was sagenderes. So,
noch ein Beispiel, so was soll hier gemacht werden,
abhängig von einer auf der Tastatur gedrückten Taste,
soll in deinem Spiel eine
von mehreren Prozeduren aufgerufen werden
Die gedrückte Taste, das ist also so ein Character offensichtlich.
Und wenn das gedrückt worden ist, dann passiert das hier.
Und dann steht hier auch brav ein Break und dann wird
hinter dieses Switch-Statement hinter den letzten Case wird dann gesprungen.
So, was passiert, wenn die Break-Anweisung fehlt,
haben wir gerade drüber gesprochen, dann wird halt einfach hier weitergemacht.
So, Fred wird da sicherlich auch noch ein Wort drüber verlieren.
Beruhigend. Das heißt, dass wenn man sich kennt,
braucht man sich nicht vorher absprechen.
So, jetzt haben wir also Sequenz,
haben wir besprochen
Verschiedene Arten von Fallunterscheidungen. Jetzt kommen kurz verschiedene Arten von Schleifen.
Sie haben bereits eine in Carol kennengelernt und Fred hat die
ja jetzt auch schon so an der einen oder anderen Stelle gesagt,
ja gut, also Schleifen, das kommt später.
Hier sehen Sie schon mal so zwei Beispiele für Schleifen,
die wir jetzt gleich mal so etwas auseinandernehmen werden,
welche Art von Schleifen das sind.
So die erste Aufgabe, die hier gestellt wird, ist,
also es wird eines dringend variable deklariert und dann steht hier sowas,
du, also tu es einfach,
Und das können sie ja jetzt schon lesen.
Hier steht jetzt ein Block von Anweisungen. Also schreibt mal
auf die Konsole Passwort und dann wird das eingelesen,
dieses Passwort. Solange, so lange, folgendes gilt,
das Passwort ist nicht gleich, nicht gleich dem,
ja, das scheint irgendeine Exemplarvariable zu sein.
Scheint nicht, also dem Passwort gleich zu sein,
also die, das da hinterlegt worden ist. So,
und diese Schleife, so wie die genau bezeichnet wird,
so welche Art von Schleife das ist,
das lernen wir gleich noch kennen,
diese Schleife hält sie fest
Die hält sie fest. Für immer. Bis sie das
richtige Passwort eingegeben haben. Sie kommen da nicht mehr raus.
Sie können nur noch den Stecker ziehen. Und dann gucken,
was da als nächstes passiert, wenn sie den Stecker wieder reinstecken.
Aber das hier ist also so in der,
in seiner ganzen Gnadenlosigkeit, so wie das da steht.
Da steht jetzt auch nicht, zähl mal den Zähler,
bescheiterte Versuche um eins hoch,
solange wie der Zähler kleiner als Max-End ist
Nein, das steht da nicht. Das ist bis ans Ende
einer Tage ihrer Tage, nicht aller Tage, ihrer Tage,
können Sie jetzt das falsche Passwort eingeben, sonst passiert da nichts.
So, das ist eine andere Art von Schleife, als die,
die sie hier ist, schon mal so in einer Ausprägung sehen.
Hier ist genau festgelegt, also von wann bis wann,
diese Schleife durchgezählt wird, nämlich von C wird zu 32,
C ist kleiner als 127 und wir zählen C,
C. Sollte man,
vielleicht soll sie mal dem nächsten Durchlauf diese Variable mal
den nennen
Also der... Ansonsten... Ich glaube,
da stand das mal anders im Standard 10,
wo es wohl schon voll genug war.
Hahaha. Ja, haben wir gellacht. So,
Fred sagte gerade, da stand mal C plus plus,
und das sollte ein Witz sein.
Da hat aber keiner drüber gelacht. Insofern haben wir das
jetzt mal wieder andersrum gemacht. Was jetzt ein ganz besonderer Witz ist,
weil der Unterschied zwischen plus plus C und C
plus plus genau an dieser Stelle ist ein Thema,
über das Fred mit ihnen von Freitagabend 17 Uhr bis Montagmorgen
7 Uhr reden kann
So im Sinne von dem Video von vor zwei Wochen,
The Expert, now you have confused everybody.
Das ist das, was dann nach 48 Stunden rauskommt,
dann nicht everybody, aber sagen wir mal mich.
Okay, so jetzt gucken wir uns diese Schleifen mal an,
was da grundsätzlich dahinter steckt. Und die zwei Begriffe hier,
die sollten sie, also die sollten sie mindestens mitnehmen.
Das eine ist, der eine Begriff ist,
ich fange mal in der Mitte an, das ist der Schleifenrumpf.
Der Schleifenrumpf ist das, was immer wieder geschleift wird.
Das, was immer wieder ausgeführt wird. Und die schleifen Steuerung,
überprüft, ob der Schleifenrumpf noch einmal, die Klammer auf,
noch Klammer zu, einmal durchgelaufen, durchgeführt werden soll.
So, und jetzt, dass so die zwei Beispiele,
die ich Ihnen gerade gezeigt habe, zeigen auch schon,
also das ist, Sie können ja unterschiedliche Motive haben,
etwas wiederholt durchzuführen.
Es kann sein, dass Sie genau wissen,
wie häufig Sie etwas durchführen müssen. Es kann sein,
dass Sie möglicherweise etwas wiederholt durchführen wollen,
aber es kann auch sein,
dass es
gar nicht passiert
Es kann auch sein, dass es mindestens einmal passiert.
Also die Welt ist daher bunt und vielfältig,
vor allem die Probleme, die sie zu lösen haben.
Und deswegen gibt es unterschiedliche Formen, Schleifen,
Steuerungen und Schleifen, Rumpf anzugeben. So, eine beliebte,
oder häufig anzutreffende Art von Wiederholung ist die sogenannte Zählschleife.
Das ist so, die haben sie,
und das ist so, die heißt so auch kurz,
viel kürzer ist es nicht.
Das ist die Vorschleife.
Die Zählschleife wird verwendet
Wenn man weiß, wie häufig der Schleifenrumpf durchlaufen werden soll.
Zehnmal, zwanzigmal, maxint, minus eins mal.
Also wenn man das weiß, dann kann man die Vorschleife verwenden,
die Zählschleife. In Java sieht die so aus,
das will ich jetzt eigentlich nur kurz gezeigt haben.
Also es gibt hier so eine Initialisierung, ein Initialisierungsausdruck,
die Nicialize Expression. Da wird also die Variable über
die iteriert wird,
wird hier deckt
Und mit einem initialen Wert versehen. Es gibt eine Abbruchbedingung für die Zählschleife,
die kleiner als 10, also 0, kleiner 10.
Und es gibt einen Ausdruck, der typischerweise diese Variable hier verändert.
Plus plus I, also auf I wird eins draufgezählt.
Die Frage wiederum, die spannende Frage,
was unterscheidet plus plus I eigentlich von I plus plus?
So, wenn Sie das mal machen, dann wird Sie das nicht überraschen.
Das Ding gerät jetzt also von 0 bis 19,
10 Mal,
wird diese Schleife durchlaufen
Dann gibt's noch so zwei andere Arten von Schleifen. Das sind,
also die sind durch das Schlüsselwort, Wile, so lange gekennzeichnet. So,
und da gibt's einmal diese positiv bedingte abweisende Schleife,
die sieht so aus, also hier steht das Wile,
das Schlüsselwort und es wird, bevor, das ist deswegen abweisend,
bevor das erste Mal der Schleifenrumpf durchlaufen wird,
wird gefragt,
ob dieser Ausdruck zu True evaluiert werden kann und
erst dann wird der Schleifenrumpf durchlaufen
Das unterscheidet diese Art der Schleife von dieser Realisierung.
Hier wird der Schleifenrumpf mindestens einmal durchlaufen und dann wird überprüft,
ob also ein zweites Mal der Schleifenrumpf ausgeführt wird.
Aber was die beiden Schleifenarten gemeinsam haben, ist,
man weiß nicht, wie häufig der Schleifenrumpf durchlaufen wird.
Das ist eben abhängig davon, wie hier diese Boulian Expression
ausgewertet wird. Das ist ja weder zeitlich noch,
also von der Anzahl her, Das ist bestimmbar.
Hier steht einfach ein Bulshar-Ausdruck und der wird es mal in dem Moment,
in dem der mit True evaluiert wird,
wird der Schleifenrumpf durchlaufen und ansonsten wird hinter das Ende des Wild Statements die Ausschübung des Codes fortgesetzt.
So, die Wildschleifen haben eine besondere Ausprägung, das sind die Endlosschleifen.
Das ist so auf Englisch heißen die Infinite Loops.
Das schreibt man dann so,
Wild True und dann weiß der Und wenn Sie das hinschreiben,
dann wissen Sie auch, was Sie getan haben.
Das hört nie auf, nie. Weil das wird immer True,
wird immer zu wahr evaluiert. Und der Schleifenrumpf wird endlos wiederholt.
Das ist die Formulierung für die Endlosschleife mit dem Wild Statement.
Oder in der Zählschleife kann man das auch kurz schreiben.
Wenn Sie das hier schreiben, wird es auch als Endlosschleife interpretiert.
Und bevor ich jetzt gleich auf Code von Apple mit einem
spöttischen Grinsen verweise. Hier, also fragen Sie die Leute,
die sich damit besser auskennen, so Infinite Loop 1,
One ist die Adresse von Apple, von Apples Hauptquartier.
Die Infinite Loop hier. Ist es schön. Nur,
dass sie es wissen. Viel interessanter ist der da.
Der da. Etzgar Deixtra. Einer, der war Titel Titanen der Softwareentwicklung,
auch schon vor ein paar Jahren von uns gegangen.
Also der wird ihnen an der einen oder anderen Stelle
in ihrem Bachelor-Master-Studio, wird er ihnen noch begegnen.
Und da können sie sich schon drauf freuen.
Hier sehen sie jetzt mal so zwei Zitate von ihm,
also deren Bedeutung wir jetzt hier so im Rahmen dieser Vorlesung nicht weiter auseinandernehmen brauchen.
Nur mal so eine, nur dass sie verstehen,
da verstehe ich schon mal einen Eindruck davon kriegen,
so wie spitzzügig der ist.
Also testen kann immer nur die Anwesenheit von Fehlern zeigen,
aber niemals deren Abwesenheit
Ja, ist ja auch klar, oder? So,
eine Sekunde, okay, eine Stunde beim ersten Hören ich,
eine Sekunde sie, wenn sie das hören,
was habe ich denn, was für eine Aussage habe ich denn,
welche Aussagekraft hat das, wenn ich sage,
ich habe das Programm getestet und ich habe keine Fehler gefunden.
Ja, genau das haben sie dann rausgefunden, dass sie keine Fehler gefunden haben.
Sie haben nicht rausgefunden, dass keine Fehler drin sind.
So, und in dem Sinne kann testen immer nur
die Anwesenheit von Fehlern, zeigen aber niemals deren Abwesenheit.
Dafür braucht es formale Beweisverfahren und das sprengt den Rahmen,
also mindestens dieser Vorlesung. So, dieser ja Deixtra,
der hat also so einer der berühmteren Artikel, in diesem Fall Leserbriefe,
die er geschrieben hat, also behandelte das sogenannte Go-To-Statement.
Und Go-To-Statement, also jetzt müssen wir erstmal kurz so,
weil das kennen sie gar nicht.
Oder? So, das haben wir ihnen jedenfalls bisher nicht beigebracht.
So sollte ich das formulieren. Das Go-To-Statement ist so in
den klassischen Programmiersprachen Ist so eine Art, also von,
also so eine Art von Amoklauf, ist,
also sie können also an irgendeiner Stelle des Programms schreiben, go too.
Und dann eine Stelle, ein Label aufrufen, also wohin
dann im Programmverlauf gesprungen wird. So, das ist deswegen,
ich habe das deswegen gerade so in Anführungsstrichen als Amoklauf bezeichnet,
weil also das ist das genaue Gegenteil von strukturierter Programmierung.
Es ist also, wenn mir nichts Besseres einfällt,
dann go to Ende und dann ist man irgendwo am Ende
oder auch nicht am Ende, höchstens mental.
Und die innere Struktur des Programms erschließt sich dem Leser sehr schwer.
Und jetzt schreibt er also, er sitzt,
dance is just too primitive, also das Go-To-Step-Tipp, selbe.
Es ist too much an invitation to make a mess of
once program. Ja, so das ist so,
das sieht im Moment, in dem man es verwendet,
hilft es einem bei der Lösung eines Problems,
dass man anders nicht in den Griff bekommt.
So am nächsten Tag typischerweise fragt man sich,
was ist da vorgegangen,
dass dieses Statement jetzt hier steht
Jetzt sind wir wieder bei dem Blöcken vom Anfang.
Das erzeugt schlechte Laune und als wäre das nicht so schlimm genug.
Es erzeugt also Arbeit, Unverständnis. Es kostet Zeit,
sich in diesen Code einzulesen. Deswegen ist also das Go-To-Statement,
das gibt es in Java, gar nicht.
Also jedenfalls nicht so, dass sie es verwenden können. Also das heißt jetzt nicht,
dass es also Fred oder ich das verwenden können und sie nicht,
nein, das ist nicht,
also es ist einfach nur ein reserviertes Schlüsselwort,
also der Compiler dann aber nicht akzeptieren wird in einem Programmtext.
So, sie können sich, also diesen den Text,
den können sie sich also nochmal durchlesen und also den finde ich insofern deswegen,
also lege ich den auch immer wieder gerne auf.
Ich finde den insofern finde ich den auf verschiedenen Ebenen interpretierbar,
als dass da ja steht, das Go-To-Statement ist ein Messer,
das ist zu scharf für den alltäglichen Gebrauch.
Die Leute schneiden sich immer in die Finger und deswegen
verbieten wir das Go-To-Statement jetzt
Also mir wird es nicht passieren. So, und das ist insofern
eine interessante Herangehensweise. Also da steckt so eine interessante Haltung hinter,
weil eine gute Programmiersprache soll es eigentlich einfach machen,
gute Programme zu schreiben.
Sie soll es nicht schwierig machen, schlechte Programme zu schreiben.
Und in dem Licht könnte man jetzt mal dieses Statement zum Go-To-Statement interpretieren,
weil das ist jetzt so in Programmiersprachenentwurf,
ist das also eigentlich
nicht entscheidbare Frage
Jemand, der weiß, was er tut. Und ich hoffe,
dass wir alle wissen, was wir tun, wenn wir programmieren,
der könnte eigentlich auch das Go-To-Statement an der richtigen Stelle richtig verwenden.
So aus Angst davor, dass es zu viele Leute gibt,
die dieses Wissen nicht haben, wird es Go-To-Statement aus den moderneren Programmiersprachen verbannt.
Als könnte man damit irgendjemand von uns hindern, schlechte Programme zu schreiben.
Das ist schon, okay, ich meine,
das Statement ist zu einer anderen Zeit, ist es gemacht worden und könnte das jetzt mal heute diskutieren. So,
und es gibt aber natürlich auch Programmiersprachen, in denen man das,
also Programmierer, die wissen, was sie tun,
die können auch in Objective C programmieren und da benutzt man,
kann man natürlich Go-To verwenden und das ist etwas,
der Code ist noch gar nicht so alt,
also iOS 7, da waren sie auch schon auf der Welt,
im Gegensatz zu 1960ern,
der Code ist noch gar nicht so alt.
So, und da hat jemand hat das Go-To-Statement so in einer Art und Weise verwendet,
also wenn man da mal so drauf guckt,
wozu führt das,
dieser Code scheitert immer
Das kann man wohl sagen. Da braucht man sich
die ganze Mühe, hier vorne gar nicht machen.
Weil dieser Coach scheitert einfach immer. Und das,
jetzt kann man sagen, okay, das überlasse ich jetzt Ihnen.
Das ist jetzt so, da können sich ihre eigene Meinung drüber machen.
Also Konsens in der Entwicklung moderner Programmiersprachen ist,
wir wollen das Licht. Ich weiß nicht,
ob das in dem Nachfolger von Objective C,
ob es dieses, wie heißt das?
Wie? Swift. Ja, ich weiß nicht,
ob es da im Go-To-Statement gibt
Dann brauche ich mich nicht zu schämen, dass ich das nicht weiß. So,
in den letzten Minuten statische und dynamische Eigenschaften, zwei so zwei,
drei Aussagen noch, damit sie die Begrifflichkeiten mal gehört haben, nämlich Sichtbarkeit und Lebensdauer.
Also wir sind jetzt mit dem Thema strukturierte Programmierung,
sind wir im Großen und Ganzen durch,
also in den Rest der Vorlesung, also nicht dieser Vorlesung,
sondern den Rest des Semesters, werden wir uns also mit Konstruktion beschäftigen,
also die dieses ganze kleinen Programmieren im Kleinen als nicht selbstverständlich,
aber doch so im im Wesentlichen als abgehakt zu betrachten.
So, jetzt kommen so Fragen, die man sich so stellen kann,
wenn wir mal die Programme beschauen, die wir jetzt schon schreiben können.
Und zwei Fragen, die sich so stellen,
sind so die Frage nach der Sichtbarkeit von Programmelementen.
Steht hier so etwas verschwörerisch und auch zur Lebensdauer von Variablen beziehungsweise Objekten.
So, ein Begriff, der dabei eine Rolle spielt,
ist der sogenannte Sichtbarkeitsbereich. Sichtbarkeitsbereich bedeutet, Wann ist eigentlich,
welche Variable, die ich mal in meinem Programm deklariert habe,
wann ist die sichtbar?
Wann kann ich die verwenden und wann nicht?
Wieso könnte das wichtig sein? Ich zeige ihnen jetzt einfach
mal so ein Stück Code. So,
und jetzt gucken wir uns mal diesen Code so kurz an und da steht also sowas wie,
hier wird eine klassenweit sichtbare Variable vom Typ Integer mit dem Bezeichner X deklariert.
Okay, das sei mal so. Warum auch nicht?
Wird dir gleich einen Wert zugewiesen
X-Witze 0, okay, sei das so. So,
jetzt gibt es eine Operation, eine Prozedur,
sieht man ja hier an dem Schlüsselwort, die heißt M1.
Und hier wird jetzt eine lokale Variable in dieser Prozedur
mit dem Namen X, aber vom Typ Double deklariert.
Darf man das? Ja. Darf man. Aber welchen
Effekt hat das? Wenn ich jetzt hier innerhalb von M1 X,
einen Wert zuweise, dann ist die Variable X,
die sichtbar ist, ist die hier lokal deklarierte.
Okay, gut. Und nicht etwa die,
die hier im Kontext von M1 deklariert ist,
die so innerhalb der ganzen Klasse sichtbar ist.
Das sieht man hier in der Prozedur M2. Wenn hier auf
X zugegriffen wird, wenn hier X referenziert wird,
dann kann das nur die Hirndeklavierte Variable X sein,
weil jede einzelne Prozedur, jede einzelne Operation bildet einen eigenen Sichtbarkeitsbereich.
Und das, was so hier stattfindet, ist der Zugriff auf einen äußeren Sichtbarkeitsbereich.
Und hier findet eine Überdeckung von X aus dem äußeren Sichtbarkeitsbereich
mit dem Lokal deklarierten X statt.
So, das muss man einfach wissen,
wenn man also mit lokalen Variablen umgeht und wie wir aus der Mail von Piep gesehen haben.
Also sie sollten sich diese Fragestellung vielleicht dann auch nochmal so im Rahmen von Beispielprogrammen,
deutlich machen, wann wird eigentlich welche variable manipuliert.
So, weil sie, nicht nur sie, ich,
wir alle machen unter anderem solche Fehler.
Da sind wir also ganz, kommen uns ganz großartig vor.
Wir deklarieren also eine private, klassenweit sichtbare, variable,
namens Stunden vom Typ Nummernanzeige. Okay. So,
im Konstruktor dieser Klasse sagen wir dann, naja,
wir wollen also dieser Entschuldigung, es war umgekehrt.
Also wir wollen jetzt, also dieser Exemplarvariablen wollen wir einen Wert zuweisen.
So, und jetzt, was jetzt passiert ist,
dass also wir einem lokalen Objekt, einem lokalen Bezeichner,
ein Objekt zuweisen und die hier oben klassenweit sichtbaren Variablen sind,
davon merkwürdig unberührt.
Wer merkwürdig ist es nicht. Hier findet jetzt einen Namensüberdeckung statt. So,
wichtig ist, so wie es hier steht,
Die sollen also nicht nochmal lokal deklariert werden,
sondern durch die hier stehende Zuweisung wird denen oben klassenweit sichtbaren Exemplarvariablen ein Objekt zugewiesen.
Jetzt haben wir also das mit der Sichtbarkeit und hoffentlich
schon mal so ein klein wenig geklärt.
Jetzt kommt noch eins. Also das können wir jetzt,
glaube ich, mal. Also dass jetzt die Sichtbarkeit nach
außen gewesen ist, das können sie ja durch diese Modifikatoren,
können sie das ja festlegen.
Was ist nach außen hin sichtbar? Jetzt haben wir gesprochen
über, jetzt habe ich gerade gesprochen,
über die Sichtbarkeit von Variablen
Innerhalb einer Klasse, ohne dass diese Modifikatoren dabei jetzt eine Rolle gespielt haben.
Jetzt brauchen wir nur noch uns über ein Konzept im Klaren
zu werden. Und das ist die sogenannte Lebensdauer.
Wie lange in Anführungsstrichen lebt, lebt eine Variable.
Und das ist eben der Fall, also die will ich
jetzt eigentlich auch nur noch eine einzige Ops, Alter.
Da wollte ich nur eine Aussage zu machen. Die Lebensdauer
von Variablen, also ist eine von der Sichtbarkeit unabhängige Größe.
Sie werden also, Red wird das gleich jetzt auch noch
in Beispielen klar machen
Keine Reaktion. Nein. Dass also die Lebensdauer von Objekten
unabhängig davon sein kann, ob der Bezeichner,
über den sie mal erzeugt worden ist,
so noch sichtbar ist oder ob der noch lebt.
Aber mit dieser mystischen Aussage sage ich jetzt immer,
sage ich das, was ich immer sage,
am Mittwoch um 15 Uhr, schönes Wochenende.
Und ich hoffe, ich kann nächste Woche aus der SE1-Betreuerrunde
eine andere E-Mail lesen oder dann sie ihnen auch vorlesen
Schönes Wochenende, üben Sie fleißig. Alles,
was wir hier machen, ist von Menschen gemacht.
Das ist kein Geheimnis dahinter. Nichts, gar nichts.
Auch das hier ist von Menschen gemacht.
Und Sie können sich das erarbeiten. Und in Erarbeiten,
da steckt was von Arbeiten drin und üben.
Und freitags gibt es ein Tutorium. Okay, und am
Wochenende ist auch noch Potenzial. Mal ganz kurz ein kleines
wissenschaftliches Experiment. Wenn ich in die Nähe dieser Tafel gehe,
ob das irgendein Einfluss, nee,
bei mir stand das
zu funktionieren
Okay. Vielleicht lag es an der Kreide, die habe
ich nicht angefasst. So. Ich wollte, glaube ich,
mal wieder eine Ankündigung machen. Dabei hilft mir immer,
das kommen Sie, weil ich ja da die Sachen immer hinterlege.
Und zwar geht es um das Blue-Jay-Buch.
Ab und zu kommen ja so Fragen, hey Fred,
welches Buch soll ich mir eigentlich holen?
Und das hatte ich ja irgendwann mal so ganz unauffällig in so
eine Ankündigung geschrieben.
Ist schon ein paar Wochen her,
glaube ich
Nee, achso, das ist Nebels. Wann habe ich
das gemacht? Naja, so vor drei Wochen ungefähr.
Da habe ich also darauf hingewiesen,
wie das Buch heißt, was ich euch empfehle.
Und ich habe auch gesagt, wir haben das in der Bibliothek.
Also wenn sich das jetzt niemand sofort kaufen will oder so,
könnt ihr auch in der Bibliothek gucken.
Und ich dachte, ich mache mal so ein kleines Live-Experiment.
Wir gucken einfach mal, wie viele Leute sich da schon ausgeliehen haben.
Also wir haben ungefähr 80 Exemplare. Wir haben einmal 40
Exemplare von der aktuellsten Auflage und 40 von der davor.
Das ist also quasi einmal die und einmal die.
Schauen wir mal, jeweils
39. Also vielleicht hat es sich einer ausgeliehen.
Und hier maximal zwei. Tja,
also wenn jemand von euch irgendwie mal gerne was lesen will abends,
es sind noch genügend Bücher da.
So, dann machen wir mal Bluejoy auf. Genau.
Ich wollte noch einmal ganz kurz das Projekt von letzter Woche öffnen.
Weil ich ja noch so ein paar Codezahlen noch gar nicht erklärt hatte.
Ich hatte euch ja gesagt, hey, das reicht,
wenn ihr das quasi so bis hier versteht
Blöde ist jetzt, ihr wisst natürlich überhaupt nicht,
wie werden eigentlich diese Methoden aufgerufen.
Und es wirkt vielleicht ein bisschen wie Magie, hey,
das hat irgendwie einen sinnvollen Namen und hier steht was Sinnvolles drin,
macht der Computer dann irgendwas Sinnvolles damit.
Nein, macht er nicht. Und ich wollte euch einmal
ganz kurz quasi die Hauptschleife zeigen des Spiels.
Die sieht man hier ganz schön auf einem Bildschirm.
Hier sind so ein paar Dinge, die ihr aus Java
noch nicht kennt, die dann in SE2 teilweise daran kommen.
Aber für das Selbststudium, das ihr einfach versteht,
hier ist quasi die Hauptschleife des Spiels,
also der sogenannte Game Loop, nennt man das ganz gerne.
Okay. Also es wird erstmal wird der aktuelle Zustand des Spiels gezeichnet,
dann wird irgendwie auf Tastatureingaben reagiert, dann wird geprüft,
ob man gewonnen hat und dann wird geprüft,
ob man verloren hat
Und diese Methoden haben wir quasi oben selber geschrieben.
Hier ist, glaube ich, noch eine Absachsungsstufe dazwischen.
Aber diese Methoden zumindest haben wir, nee,
stimmt auch nicht, jetzt auch eine Absachsungsebene dazwischen.
Dieses Check-Win ist hier und hier wird die Methode aufgerufen,
die wir oben geschrieben haben. Und bei dem Check-Fail werden
diese beiden Methoden aufgerufen, die wir oben geschrieben haben. Ja,
also denk bitte nicht, nur weil eine Methode sinnvoll,
einen sinnvollen Namen hat, dass der Computer irgendwas versteht,
welchen Sinn die haben soll,
sondern nur wenn die Methoden tatsächlich aktiv aufgerufen werden,
passiert dann auch irgendwas, das, was da drin steht.
Okay. Ja, und das lernt ihr hier alles
in SE2, wie man solche Dialoge aufmacht und so.
Okay, und diese Zeile Sorgt einfach dafür,
dass das alle 40 Millisekunden ausgeführt wird.
Okay, das war das. Dann wollte ich einmal das Projekt aufmachen,
was ihr letztes oder ja letzte Woche in der Übung hattet.
Da habe ich schon mal so ein bisschen programmiert.
Genau. Und ich habe mal so ein bisschen so einen Zeitraffer angemacht,
weil ich jetzt nicht hier stundenlang mit euch sitzen wollte.
Und manchen Leuten ist aufgefallen, dass es einen Fehler in dem Projekt gibt.
Wem ist aufgefallen, dass es einen Fehler in dem Projekt
gibt? Ja, so ein Drittel der Leute ungefähr.
Ungefähr jetzt sieht man es ganz gut. Also wenn so
eine halbe Stunde rum ist, sieht man hier oben,
ist der Stundenzeiger nicht weit genug gegangen.
Und ich wollte das einmal ganz kurz erklären,
weil ich da erstmal selber total irritiert war von dem Bug
Das liegt einfach daran, dass der Winkel,
in dem diese Zeiger sich befinden sollen,
abhängig gemacht werden davon, welchen Wert man hier übergibt.
Und ich hatte mir so überlegt, naja, der Minutenzeiger,
muss ich ja 60 mal so langsam drehen,
wie der Sekundenzeiger, weil ja eine Minute 60 Sekunden hat.
Und dachte ich so, ah,
mit der Begründung eine Stunde hat ja 3600 Minuten,
dann müsste es irgendwie sinnvoll sein, wenn man hier 3600 übergibt.
Das funktioniert aber nicht. War ja die Anzeige dieser kleinen Striche,
sag ich jetzt mal, von denen es 60 gibt,
also unter diesen Dicken sind die Kleinen ja sozusagen auch.
Die sind sowohl für die Minuten als auch für die Sekunden,
für die Anzeige da, aber für die Stunden verwendet man die nicht.
Warum nicht? Der Tag hat ja nun mal nicht 60 Stunden.
Ja, also wenn eine halbe Stunde vergangen ist,
muss ich nicht einen halben kleinen Strich gehen,
sondern einen halben großen Strich.
Und da der sozusagen fünf Strichen entspricht, muss man dann
einen anderen Faktor angeben. Das heißt, man muss hier,
was ist 3600 durch fünf, Dankeschön, 720.
Und dann müsste was Sinnvolles wissen. Dann ist natürlich
die Dokumentation sinnlos, das muss ich also überarbeiten fürs
nächste Jahr
Aber das fand ich ganz spannend, dass so vielen Studenten
das aufgefallen ist, dass da dieser Fehler drin ist.
Das wird euch im Arbeitsleben wahrscheinlich auch ab und zu passieren,
dass ihr irgendwelche Projekte kriegt, wo mal ein Fehler drin ist.
Also jetzt dadurch, dass wir das quasi jetzt
fünfmal so schnell gemacht haben, landet er jetzt hier.
Das sieht doch ganz gut aus. Okay. Gut. Ach,
jetzt habe ich das eine Projekt ein bisschen zu früh geschlossen.
Lido hatte ja noch was erzählt über das Switch,
das wollte ich auch nochmal ganz kurz zeigen
Genau. Das ist fast so ähnlich wie das, was auf den Folien war.
Es geht hier um Spieleprogrammierung, das ist irgendwie totaler Zufall.
Also man kann das Switch auch außerhalb von Spieleprogrammierung verwenden.
Genau, wir haben hier eine Methode. Diese Methode wird
immer aufgerufen, wenn ich auf eine Taste drücke.
Und diese Methode wird immer aufgerufen, wenn ich eine Taste loslasse.
Und da wird es dann ein sogenanntes Key-Event übergeben.
Und ich kann dieses Key-Event fragen, hey, welche Taste wurde denn gedrückt?
Und ich kann noch so ein paar andere interessante Dinge fragen.
Und dann switche ich einfach darüber. Ich sage ja,
diesem Event-Objekt, gib mir doch mal den Tastencode,
müsst ihr dann einfach mal ausprobieren, vielleicht mit System auf Printline,
was die verschiedenen Tastencodes sind.
Also zum Beispiel Cursed, hast du links da diesen Code,
warum auch immer. Die Frage könnt ihr euch jetzt nicht beantworten,
warum das so ist, das ist Cursed rechts,
das ist Cursed oben und das ist Cursed unten
Gibt es als Konstanten? Ah. Okay, dann wäre
der Quelltext vielleicht ein bisschen lesbarer, anstatt mit diesen magischen Songs.
Okay. Das heißt also, wie diese Switch jetzt funktioniert,
ist folgendes, er schaut sich also den Keycode an,
das ist irgendeine Int-Zahl und schaut dann,
ob er einen entsprechenden Fall in dieser Liste der Fälle findet.
Also wenn ich jetzt zum Beispiel jetzt die Leertaste drücke,
wird er halt gucken, okay,
taucht ja irgendwo der Code für die Leertaste auf,
ich vermute mal, das ist vielleicht 32 oder so,
ich weiß es aber nicht.
Würde er feststellen, nö, es gibt dafür keinen Fall,
da muss ich nichts machen. Während wenn ich zum Beispiel Cursor rechts drücke,
dann wird er feststellen, ah,
hier ist der Fall für Cursor rechts,
da muss ich jetzt im Prinzip eigentlich den gesamten Code ausführen,
der jetzt noch kommt, Ausnahme,
wenn ich vorher einen Break finde und das finden wir hier.
Da muss ich also diesen Code ausführen.
Und wenn ich zum Beispiel Causa unten drücke,
muss ich diesen Code ausführen und wenn ich Causa links drücke,
muss ich diesen Code ausführen.
Also vergesst bitte niemals diese Breaks. Wenn diese Breaks hier nicht stehen würden,
dann würde er quasi diesen ganzen Code ausführen für Cursor Links und für Cursor Rechts
, würde er das ausführen für Cursor oben das.
Und das hätte dann irgendwelche Effekte, die ihr nicht haben wollt.
Gut, also bitte nicht die Breaks vergessen. So,
das ist das eine Beispiel, was ich zu einem Switch habe.
Wir kommen hoffentlich noch zu einem anderen Beispiel. So,
dann öffne ich jetzt mal das Projekt,
wo es um die Schleifen geht,
dann macht das andere mal zu,
sonst bin ich immer
so verwirrt
Das kann eigentlich auch mal zu. Genau. Also Hauptthema
dieser Woche ist ja Schleifen. Und es gibt in dem Projekt,
was ihr bekommt, gibt es quasi diese beiden Klassen.
Die beiden habe ich jetzt mal dazu geschummelt,
warum die Psycho heißt, werdet ihr gleich noch sehen.
Genau, und hier ist jetzt schon Code vorgeben,
ihr müsst in dieser Klasse nichts selber schreiben.
Und ich wollte mal ein paar Methoden ausführen mit euch
und dann mal versuchen, die nachzuprogrammieren.
Das Beispiel hatte Guido, glaube ich, schon auf den Folien,
aber wir können es ja trotzdem nochmal machen.
Es gibt also eine Methode, die sowas auf die Konsole schreibt,
null ist eine Ziffer, eins, seine Ziffer und halt runter bis neun.
Diese zehn Zeilen sollen geschrieben werden. Und wenn man jetzt
noch keine Schleifen kennt, kann man das ja zum Beispiel so machen.
Ja, das war jetzt quasi meine erste Annäherung in dieses Problem.
Also, wenn ich das mal ausbilde mit unserer eigenen Klasse,
müsste das genauso funktionieren. Schreibe alle ziffern, funktioniert auch
. Aber das ist natürlich nicht der Sinn der Übung.
Aber ich finde es eigentlich immer ganz gut, so anzufangen,
dass man sich also klar macht, ich will ja,
dass im Prinzip zur Laufzeit diese zehn System-Out-Printlines ausgeführt werden.
Und jetzt versuchen wir mal irgendwie eine Struktur darin zu sehen,
irgendwas, was ähnlich ist und was ihr vielleicht schon sehen werdet.
Im Prinzip wird ja hier immer dasselbe ausgegeben, nur dass
diese Zahl sich ändert. Jetzt ist es ziemlich schwierig,
eine Zahl in einem Stringen variabel zu halten.
Deswegen machen wir jetzt mal einen kleinen Trick
Ich nehme jetzt erst mal diese ganzen Gänsefühlchen hier weg und
dann packe ich sie anschließend hier wieder dazu.
Zock, zock, zock. Ich habe es jetzt quasi aus
dem String rausgenommen und dann gucke ich mal noch irgendwie so ein Plus davor.
Vielleicht wäre es schneller gegangen, wenn ich es in die Zwischenablage getan hätte.
Was bedeutet es, wenn ich ein Int und ein String
iddiere? Naja, Java ist schlau genug zu sagen,
eigentlich mal Addition auf Int und Strings, der so mathematisch nicht wirklich Sinn.
Dann wandle ich mal diese Zahl erst mal in einen String
um und dann verkette ich quasi diese beiden Strings.
Ich hänge dann diese beiden Strings aneinander. Der müsste also
exakt dasselbe Ergebnis bei rauskommen
Ich jetzt vor allem, warum macht, fragt das Frett,
das sind, wenn da exakt dasselbe Ergebnis rauskommt?
Das zählt jetzt, funktioniert immer noch. Das Tolle ist jetzt,
ich bin jetzt nicht mehr in einem String,
sondern das ist jetzt ein eigenständiger Ausdruck für sich gesehen.
Also ich könnte jetzt hier auch irgendwelche Rechnungen hinschreiben oder Variablen
oder Funktionsaufwohl oder Funktionsaufruf oder was auch immer.
Und hier bietet es sich noch Variable an. Wir können
die Variable mal ihn nennen. Das ist immer so klassisch,
wie man Variablen gerne nennt, wenn es um Schleifen geht.
So, und ich könnte diese Variable jetzt zum Beispiel mal
mit null initialisieren, dann könnte ich das auf die Konsole schreiben.
Dann könnte ich ihn anschließend um einen erhöhen
Und jetzt könnte ich das zehnmal machen. Sind das jetzt zehn,
eins, zwei, drei, vier, fünf, sechs, sieben?
Das sind die zehn. Das müsste immer noch funktionieren.
Schauen wir uns mal ganz kurz an.
Wir überzeugen uns, dass es wirklich funktioniert.
Wir testen es jetzt und versuchen mal keine Fehler zu finden.
Genau, es macht immer noch dasselbe wie vorher.
Was ist denn jetzt der Vorteil daran? Es ist jetzt ja
viel komplizierter als vorher eigentlich. Das Spannende ist jetzt,
dass hier jetzt tatsächlich zehnmal exakt derselbe Code steht.
Hier ist jetzt nicht mehr was im Detail irgendwie anders,
leicht andere Zahlen oder so, sondern das ist wirklich zehnmal exakt derselbe copy,
gepastete Code, falls das das mittlerweile auf Deutsch gibt,
diese Redewendung.
Ich will also diesen Code zehnmal ausführen
Ciao. Oder man könnte es auch anders formulieren.
Ich könnte sagen, ich will den Code ausführen,
solange I kleiner ist als zehn. So, ups,
genau. Das wäre also ein Beispiel für unsere erste Wirel-Schleife.
Man muss jetzt nicht mehr als Vorschleife machen, es geht
auch mit einer Wirel-Schleife, das ändern wir gleich noch.
Und ich wollte dieses Beispiel jetzt mal mit euch zusammen durchsteppen,
weil ich glaube, es versteht, ihr könnt mir das glauben,
dass es das Richtige macht, aber wir wollen das gerne sehen.
Also ich mache hier mal einen Breakpoint,
jetzt muss ich hier wieder wahnsinnig viel durch die Gegend schieben,
mein Hobby von mir
Dann starten wir das nochmal. So,
mache ich das auch nochmal ein bisschen kleiner,
aber gleich kommt ja die Konsole, die wollen wir ja auch sehen.
Was sehen wir jetzt hier alles? Gut,
wir sehen erstmal in welcher Methode wir drin sind.
Das ist noch nicht besonders spannend. Hier kommen diverse Variablen sehen,
da gibt es auch noch keine. Ich mache jetzt mal
den ersten Step. Ich sage also jetzt zum System,
ich möchte diese Variablen in die Welt rufen.
Ich möchte I deklarieren und ihr ein Startwert zuweisen.
Ja, jetzt sieht man sie hier unter lokalen Variablen.
Ihr hört den Wert null. Gut. Jetzt wird geprüft,
kennt ihr ja aus Carrick im Prinzip die Wahlschleife,
nur dass ich jetzt hier nicht from this Kiel steht.
Es wird jetzt geprüft, ob I kleiner als 10 ist.
Also es wird geprüft, ob null kleiner ist als 10.
Ja, es ist der Fall.
Das heißt, wir sollen den Schlafenhof einmal komplett ausführen.
Gut, gehen wir so ran in den Schlafen rum.
Jetzt wird also das auf die Konsole geschrieben,
hier ist die Konsole
Und jetzt soll das I erhöht werden. Achte mal darauf,
was jetzt hier passiert. Jetzt haben wir es erhöht.
Jetzt ist der Schlafenhof komplett durchgelaufen und jetzt genau wie bei Kerl
springt jetzt das System wieder nach hier oben und prüft die Bedingungen erneut.
Okay, eins ist immer noch kleiner als zehn,
wird auf die Konsole geschrieben und wird auf zwei erhöht.
Zwei ist immer noch kleiner erzählt,
wird auf die Konsole geschrieben, wird auf drei erhöht.
Deswegen mache ich jetzt nicht alle Schritte.
Ich spinne jetzt mal hier so ein bisschen im Fast-Forward-Modus.
So, jetzt erhöhen wir die Acht auf die Neuen
und prüfen ab neun, kleiner ist als zehn.
Das ist tatsächlich der Fall. Wir gehen rein,
schreiben das neun eine Ziffer ist und was wird jetzt als
nächstes passieren?
Wir erhöhen ihr auf zehn
So, ne? Ihat, jetzt sind wir zehn.
Das wollen wir eigentlich nicht mehr auf die Konsole schreiben.
Also jetzt schaut wieder das System,
ist zehn kleiner als zehn, nein. Das heißt also,
ich überspringe bitte den Schleifen rum und mache da drunter weiter.
Du, und da ist jetzt nichts mehr zu tun, ne?
Tja. Gut, dann sind wir jetzt durchgelaufen.
Habt ihr Fragen zur Wirel-Schleife? Ja, das ist nicht
eingeladen, was unterkühlt wird. Hätte man das verkürzen können?
An dieser Stelle zum Beispiel? Hätte man machen können,
aber ich mache es ungern, weil das wäre Anfänger
immer sehr verwirrend
Sonst keine Fragen. Nee, gut. Ist ja auch
recht einfach bis jetzt, ne? Jetzt hatte Guido aber
ja schon gesagt, eigentlich ist es ja pragmatisch so,
man verwendet die Wildschleife, wenn man nicht so genau weiß,
wie oft der Schleifenrumpf ausgeführt werden soll.
Aber wir wissen ja im Prinzip, der soll zehnmal ausgeführt werden.
Eigentlich ist es ja eher von der Charakteristik her eine Zählschleife.
Also ich kopiere mir einmal kurz den Quelltext für den Kontrast,
dass ihr vergleichen könnt. Machen wir das, nenne ich mal,
irgendwie vielleicht noch mal ein Wild dahinter oder so.
Und jetzt versuche ich mal aus der Wildschleife eine Vorschleife zu machen.
Also dann ersetze ich doch einfach mal dieses Schlusswort Wild durch Four,
dann schreibe ich hier mal diese Mikolon hin und hier auch,
denn der Vorschlag,
da gibt es ja im Kopf quasi in der Schleifensteuerung drei Bestandteile,
der mittlere Bestandteil ist genau wie in der Wild-Schleife einfach eine Schlafenbedingung.
Soll ich nochmal rein in die Schleife oder nicht?
Und das ist hier exakt dieselbe Bedingung. So,
dann der erste Bestandteil ist die Initialisierung des Schleifenziehendes.
Das schiebe ich da jetzt einfach so ganz mechanisch rein.
Ach, jetzt habe ich da zwei Symikola,
das wollte ich natürlich nicht. So,
und der dritte Bestandteil im Kopf der Schleife ist,
was soll denn mit dem Schleifenzähler passieren,
nachdem wir einmal die Erhöhung gemacht, nachdem wir einmal den Schleifenhof durchgeführt haben.
Jetzt will ich mich nochmal davon überzeugen,
ohne dass es schrittweise durchläuft,
dass das
wirklich dasselbe macht
Also wir machen das jetzt einmal mit der Wahlschleife,
das funktioniert, dann machen wir es mit der, ups,
dann machen wir es mit der Vorschleife, funktioniert auch.
Vielleicht machen wir doch noch mal ganz kurz das mit einem Haltepunkt,
weil ich immer ganz gerne eine Sache veranschauliche oder euch zeige,
die nicht so schön anschaulich ist.
Was passiert, wenn man auf einen Step drückt?
Man könnte ja erwarten, der erste Step ist zu sagen,
dass I muss initialisiert werden und dann würden wir anschließend hier warten,
um die Bedingungen zu prüfen.
Tatsächlich ist es aber so, dass der Blutjet die Bagger Zeilen
orientiert ist. Er wird also erst dann wieder anhalten,
wenn der Kontrollfuß in einer neuen Zeile ist.
Das ist schon ein bisschen blöd. Das heißt also,
die Tatsache, dass das hier noch geprüft werden musste,
wurde jetzt so ein bisschen vorgespult sozusagen
Okay. Dann, nun, wenn jetzt der Schleifenbund auf einmal durchgelaufen ist,
muss ja das I erhöht werden und anschließend muss die Bedingung geprüft werden.
Wenn ich jetzt Step sage, passiert das auch wieder beides sozusagen zusammen,
direkt hintereinander, weil es an derselben Zeile steht.
Das heißt, wir landen sofort wieder hier drin,
weil eins kann das erzählen. Das ist so ein bisschen schade,
dass man jetzt die Zwischenschritte nicht mehr so schön sieht.
Und deswegen haben wir in dem Ausgangsprojekt, um es für euch
nachvollziehbarer zu machen, haben wir das ein bisschen anders formatiert.
Wir haben das einfach in eigene Zeilen getan,
diese drei Komponenten der Vorschläufe. Da wird jetzt jemand,
der schon mal programmiert hat, sagen,
was soll das denn,
sowas macht man doch normalerweise nicht.
Aber für Anfänger, whoops, ich habe den Breakpoint vergessen.
Für Anfänger ist es deutlich besser nachzuvollziehen. Nur weil ich jetzt sagen kann,
okay, im ersten Schritt will ich das I initialisieren,
im nächsten Schritt will ich prüfen,
ob E-Client das als zehn Jahr ist es,
dann gehe ich mal in den Schlafen rumfahren,
dann führe ich den Schlafen rum aus,
dann muss ich das I um einen erhöhen und dann muss ich prüfen,
ob das I immer noch klein genug ist.
Dann werden nicht irgendwie zwei Schritte gleichzeitig gemacht. Nur falls
ihr euch wundert, dass das so komisch formatiert ist.
Okay, ich mache das jetzt mal wieder rückgängig,
weil selbst mich irritiert das,
das sieht irgendwie komisch aus,
wenn das nicht in derselben Zeit ist
Okay, also diese beiden Methoden machen jetzt exakt dasselbe,
so würde man das normalerweise hinschreiben. Man kann es rein technisch auch so machen,
aber hier ist es einfach so blöd,
der Startwert von I steht irgendwo hier, die Bedingung steht irgendwo hier,
oft sind Schleifen rum für dann auch mal vielleicht eine halbe Bildschirmseite,
dann muss man gucken, wo wird denn jetzt genau der Schleifenzähler erhöht.
Und wenn das alles in derselben Zeile steht,
diese Schleifensteuerung, wo geht's los,
wann soll ich noch reingehen und wie verändert sich der Schleifenzähler,
dann versteht man einfach schneller mit einem Blick, ach ja,
das ist so eine Standardschleife, so eine Standardschleife,
die von 0 bis 9 hochzählt, das kenne ich,
kann ich schon mal dann gedanklich mich um was anderes kümmern.
Also Zählschleifen in Java immer mit so einem Fonds machen.
Habt ihr dazu noch Fragen
Nö. Okay, warte, machen wir doch mal einfach weiter mit den Beispielen.
Das ist also, wie gesagt, der 90% Standardfall.
Man fängt eigentlich fast immer bei null an und zählt in
einer Schritte hoch. Man kann aber im Prinzip anfangen,
wo man will. Man sieht also hier ein Beispiel.
Ich kann das jetzt erstmal wieder so vereinfachen wie oben.
Ich nehme das mal hier einmal ganz kurz weg.
Dann schreibe ich das hier wieder ganz schnell hin.
Dann schreibe ich die Pluszeichen wieder dahin.
Und wir versuchen jetzt wieder die Struktur zu sehen,
um da irgendwie den Code zu vereinfachen.
Okay, also das ist quasi das einzige, was sich ändert.
Ich könnte hier also wieder eine Schleifenvariable nehmen,
die restlichen Zahlen kommentiere ich mal aus,
dass ihr noch seht,
was da vorher stand
Und dann ist wieder die Frage, was ist denn dann
eine sinnvolle Schleifensteuerung dafür? Also wir müssen uns ja fragen,
wie soll initialisiert werden, Bedingungen quasi und irgendwie zählen oder so,
nenne ich das jetzt mal ganz stumpf.
Was sollte denn hier sinnvollerweise stehen? Die erste Zahl,
die wir ausgeben wollen, war ja hier null.
Deswegen haben wir mit null angefangen. Was wäre denn
jetzt hier irgendwie sinnvoll hinzuschreiben? Ja, mit neun.
Wir wollen ja mit neun anfangen. Also Isol bitte
den Wert neun haben
Überlegen wir uns mal, wie soll das Isig denn nach jedem Schlafendurchlauf ändern?
Hier war es ja so, wir wollten in einer Schritte hochziehen.
Also haben wir gesagt, plus plus I. Wie soll sich
denn hier das I im jeden Schlafendurchlauf ändern?
Oder nach ihrem Schlafendurchlauf? Immer diese, du? Um
drei kleiner werden. Und da gibt es jetzt verschiedene Möglichkeiten,
wie man das schreibt. Man kann zum Beispiel schreiben,
I ist gleich Iminus drei. Das heißt also, liebes Java-System,
rechne doch mal aus, was steht gerade in I drin?
Und wenn ich davon drei abziehe, welcher Wert kommt da
raus und dann stopft den mal wieder in die Variable I rein.
Man kann das auch ein bisschen abkürzen und schreiben,
I minus gleich drei. Vielleicht ist das ein bisschen lesbarer
, weiß ich nicht. Könnt ihr euch selber überlegen,
macht keinen Unterschied
Okay, und jetzt müssen wir eine,
wenn ich jetzt hier einfach zum Beispiel True hinschreiben würde,
das können wir ja vielleicht mal aus Spaß machen.
Dass ihr mal seht, eine halbwegs sinnvolle Endlosschweifung.
Ich muss da mal sehen, dass ich die relativ schnell stoppe.
Wie mache ich das denn mal sinnvoll? Also so.
So, und dann Stoff. Sieht man jetzt noch,
dass ich, ah nee, hm,
kann ich nicht irgendwie sagen, unlimited buffering.
So, jetzt probiere ich das nochmal. Zack. Zack
, zack, zack, zack, zack. So,
ich hoffe, dass man noch den Anfang sieht.
Gut, also am Anfang der Ihnen wird neun,
dann sechs, dann drei, dann null.
Tja, also ich muss jetzt quasi eine Bedingung finden,
die für diese vier Zahlen gilt und die für diese Zahl nicht mehr gilt,
damit wir dann aus der Schleife rausgehen.
Welche Bedingungen gilt für 9-6-3-0,
aber nicht für minus drei, ja?
Größer gleich neu, das klingt doch sehr gut.
Also, I größer gleich, neun. Ich möchte
nur Zahlen ausgeben, die größer gleich null sind.
Wenn du irgendwann mal unter null landest,
dann sollst du bitte aufhören mit der Schleife.
Probieren wir das doch mal aus
Ja. Das ist genau das, was wir haben wollen. Sehr schön. Das ist irgendwie,
wenn man so eine Schleife entwickelt, eigentlich immer das,
was am schwierigsten ist, sich zu überlegen,
wenn man sich noch nicht klar gemacht hat, wie sich das I ändert.
Also ich finde die Reihenfolge am einfachsten,
das ist eigentlich fast trivial, wo so als Anfang,
das weiß man eigentlich sofort, dann stellt man sich die Frage,
wie ändert sich das Ganze,
dann kann man sich quasi so eine unendlich lange Lüste machen,
was wäre, wenn es eine Endlosschleife wäre.
Und dann überlegt man sich, was passiert eigentlich an diesem Punkt mit den Zahlen?
Warum ist diese Zahl noch erlaubt und die nächste nicht?
Wie kann ich das durch eine Bedingung in Java ausdrücken?
So, okay. Darfst du noch fragen?
Ja. Gut, schmeckt es ja, aber Ektor,
die drei Kicker,
die minus minus treffen
Ah, okay, du würdest also sagen,
da müsste man hier auch anders anfangen, oder?
Okay. Ja, du meinst sowieso, und dann meinst du,
könnte man hier doch einfach das Dreifache von ihr auf die Konsole schreiben.
Ja, da gibt es also oft mehrere Möglichkeiten.
Das kommt dann immer so ein bisschen darauf an,
was man dann wirklich in der Schleife macht,
wodurch der Code dann einfacher oder lesbarer wird.
Schauen wir mal ganz kurz, macht der exakt dasselbe.
Das heißt, ihr würdet die Werte 3, 2,
1 und 0 durchlaufen, bei minus 1 wird er rausgehen
und wir schreiben immer das Dreifache auf die Konsole.
Achso, es ist natürlich jetzt mathematisch,
kann man sich recht schnell davon überzeugen,
dass dreimal ihr durch drei teilweise ist,
ja.
Stimmt. Gut
Okay, dann gehen wir nochmal vielleicht hier zu deinem
letzten Problem, was ich vorbereitet hatte, zum Nachprogrammieren.
Ja. Mit Modulon. Achso,
man könnte quasi alle ganzen Zahlen durch und immer prüfen,
ob sie durch drei Teile ist oder nicht.
Und wenn sie durch drei Tage ist, gibt man es
auf die Konsole. Das könnte man machen. Das wäre
ein bisschen umständig, weil man könnte es machen.
Kannst du gerne mal als Hausaufgabe machen.
Ja. Ich wusste, dass diese Frage kommt.
Sie kommt jedes Jahr. Okay, muss ich mal versuchen,
dass ich da ein gutes Beispiel finde.
Ich mache mir mal
eine Variable
Ja, von ihr aus ich, ist ja egal,
wie sie heißt, und tu sie mal auf 5. Gut,
dann mache ich mal eine Variable X. Oh.
Die Variable X gibt es schon. Hat das jetzt
irgend so ein internes Detail von Blu-Jay? Okay,
dann nenne ich sie halt Y, mir auch egal.
Ich will sie nur deklarieren. Gut. Und jetzt sage ich mal Folgendes.
Y soll den Wert von Plus Plus I haben. Das bedeutet,
bitte erhöhe den Wert von I. Und anschließend soll der neue
Wert von I in der Variable Y gespeichert werden.
Wir würden also erwarten, dass anschließend in beiden Variablen
der Wert von Y. Der Wert 6 drinsteht,
Da steht sechs drin. Und da steht auch sechs drin.
Gut. Jetzt tue ich immer wieder auf fünf zurücksetzen,
damit es nicht zu verwirrend ist.
Und jetzt sind wir wieder bei fünf.
Und jetzt schreibe ich mal Y ist gleich i plus plus.
Das hat folgenden Effekt. I wird auf sechs erhöht.
Und fünf wird an Y zugewiesen. Schauen wir uns kurz an.
Ihr hat anschließend den erhöhten Wert sechs und Österreich hat sozusagen
noch den Wert, den I vor der Erhöhung hatte.
Ja, das finde ich tendenziell verwirrend.
Und deswegen verwende ich nach Möglichkeit immer das Plus plus I.
Erst erhöhen und dann was mit dem neuen Wert machen.
Erst erhöhen und dann was mit dem alten Wert machen,
ist irgendwie komisch.
Zumindest für Programmieranfänger
So, was wird denn hier mit dem Wert gemacht?
Steht hier irgendwie, X ist gleich iPlus Plus oder steht hier irgendwie,
rufe eine Methode auf und übergib ihm minus minus als Parameter oder so.
Nein, steht hier nicht. Also dieser Ausdruck, i-minus minus
ist nicht Teil eines größeren Ausdrucks. Und deswegen ist es egal,
ob da sozusagen der alte oder der neue Wert von eBay rauskommt.
Mit dem wird ja hier sowieso nichts gemacht.
Deswegen ist es an dieser Stelle egal. Also wenn hier
irgendwie aus irgendeinem blöden Grund stehen würde, ah,
ist gleich i-minus minus, dann würde es einen Unterschied machen.
Aber das steht hier ja nicht. Deswegen ist es in
solchen Schleifen völlig egal. Es gibt oft Programmieranfänger,
die glauben, wenn ich das minus vorne oder hinten hinschreibe,
dann wird das beeinflusst, ist, wann das,
ob es vor oder nach dem Schleifenraum ausgeführt wird,
das ist überhaupt nicht so
Macht hier wirklich keinen Unterschied. Ja. Mal gucken.
Vielleicht finden wir irgendwann mal im Semester einen sinnvollen Anwendungsteil für
dieses Plus-Plus hinter dem variablen Namen.
Meistens braucht man das nicht. So, ach Gott,
wir haben noch eine Viertelstunde. Ich glaube, ganz ehrlich
, dann überspringe ich das mal. Oder wir schieben es
nach hinten. Vielleicht kommen wir später nochmal dazu.
Ich wollte auch ein bisschen mit euch über Strings reden,
weil die in der Übung relevant sind.
Also wenn wir in der Übung hier eine kleine Aufgabe,
Strings bieten sich wunderbar an, um was mit Schleifen zu machen, warum?
Man kann sich vorstellen, wenn man so einen langen String hat,
kann ich zum Beispiel über alle Zeichen des Strings iterieren,
kann mir die Zeichen angucken,
kann sie analysieren,
sind das irgendwelche Punkte oder Kommata oder Leertasten
oder so
Und dazu muss man einmal wissen,
wie man mit Strings überhaupt umgeht in Java.
Bis jetzt haben wir noch nicht so wahnsinnig viel mit denen gemacht,
außer die durch die Gegend zu reichen und auf die Konsole zu schreiben.
Was kann man mit so einem String alles machen?
Also wir haben hier eine Methode, die prüft,
ob der String, den ich übergebe, eine Frage ist.
Und das ist jetzt nicht besonders intelligent, es wird einfach nur geguckt,
das probieren wir einmal ganz kurz interaktiv aus.
Ob das letzte Zeichen ein Fragezeichen ist. Und wenn wir
das einmal ausprobiert haben, dann versuchen wir zu verstehen, warum das funktioniert.
Oder so, ich mache das vielleicht mal in der Direkteingabe,
ich nenne das mal A,
schöner Name, der da vorgeschlagen wird.
Wie heißt die Methode
Ich muss jetzt wahrscheinlich die nächsten 15 Minuten grinsen,
bitte nehmen wir das mir nicht übel.
Ist Frage. Ist Frage. Also ist es zum Beispiel
, hallo, eine Frage? Nein. Wie ist es
mit Testausrufezeichen? Ist auch keine Frage. Oder das frage
ich immer ganz gern, ob das eine Frage ist.
Ist auch keine Frage. Also da ist zwar
irgendwo so ein Fragezeichen, aber eben nicht am Ende.
Gut, aber wenn ich ja zum Beispiel sage,
ist das mal eine schöne Frage.
Wie lautet das Passwort?
Das ist eine Frage. Das System ist also
irgendwie schlau genug gewesen zu wissen, hey,
wie komme ich denn an das letzte Zeichen des Drinks?
Und dann schaue ich mir das mal an.
Gut. Dann vielleicht einmal den Code dazu angucken. So,
das habe ich jetzt sehr explizit in viele kleine Einzelschritte aufgeteilt.
Nur fürs Verständnis. Normalerweise würde man das in eine Zeile schreiben.
Also ich kann erst mal so einen String fragen,
wie lange er ist. Das können wir ja mal machen
. Wie lange ist zum Beispiel dieser String?
Vier. Das sollte einen jetzt nicht erstaunen. Das Test,
die Länge vier hat, schieben wir so ein bisschen noch hier.
Dann ziehe ich ein, Von dieser vier in diesem Beispiel ab,
weil ich wissen will, an welcher Position das letzte Zeichen steht.
Also diese Zeichen werden quasi bei null aufgehend Nummeriertor.
Das T steht anstelle null, das E anstelle 1,
das S anstelle 2 und das T anstelle 3. Das gucken wir auch mal ganz kurz,
das kann man also mit dieser nächsten Operation sich angucken.
Ich kann also fragen, welches Zeichen steht an einer bestimmten Position.
Und Position 1 steht an, das geht ja auch Crosser Oma,
das geht auch, was steht an Positions,
was steht an Position 2 und was steht an Position
3. Ihr dürft also bei diesem Spring, an einem Stringdaling 4,
durft ihr fragen, was steht an die Position 0 bis 3?
Ihr dürft aber zum Beispiel nicht fragen,
was steht an Position 4,
da kriegt ihr
irgendeine Acception
Eine String-Index-out of Bounce-Acception. Die kriegt ihr mal dann,
wenn ihr Oppositionszugreift, die es nicht gibt.
Ist vielleicht auch im ersten Augenblick ein bisschen verwirrend,
aber der String hat doch vier Zeichen.
Warum darf ich nicht an Privatposition 4 zugreifen?
Weil die eben von 0 bis 3 durchnummeriert sind.
Nicht von 1 bis 4. So. Genau, also wie lang
ist er? 4, 4, minus 1 ist 3
und dann wird hier geguckt, was steht an Position 3?
Das merken wir uns in der Variable letztes Zeichen.
Und dann prüfen wir einfach nur, ist dieses Zeichen gleich mit dem Fragezeichen?
Und da kommt dann Schuhe raus oder das Comforts raus,
das speichern wir uns in dieser Variable und dann geben wir
den Inhalt dieser Variable zurück.
Das sorgt also dafür, das sind fast allen Strings.
Forts zurückkommt nur, wenn es mit dem Fragezeichen Ende
kommt,
eben Schuhe zurück
Zu diesen Methoden noch fragen, längst und Char-Ed, die müsst ihr verstanden haben,
sonst habt ihr, glaube ich, Probleme in der Übung.
Nö. Gut. Man kann das auch an eine Zeile machen,
also hier dieses Text-Lenks ist quasi dieses,
dann direkt ein Abziehen ist quasi dieses,
dann dieses Text-Char-Ed ist quasi dieser dritte Schritt und dieser Vergleich
ist dann quasi dieser Schritt und ich habe mir gespart,
dass so eine Variable zu tun und ich habe es direkt zurückgegeben.
Diese beiden Methoden machen exakt dasselbe.
Hier für Anfänger leicht verständlich, hier real world code sozusagen
Gut, wenn ihr das so keine Fragen mehr habt,
würde ich ganz gerne mal ein Problem mit euch lösen,
was nicht aus der Übung ist.
Genau. Vielleicht verschiebe ich das mal so ein bisschen nach unten.
So, dass man es normalerweise nicht sieht, genau.
Schaut euch doch mal irgendwie diesen String hier unten an.
Feature-Films, bla bla bla. Und eure Aufgabe ist es
zu zählen, wie oft der Buchstabe F daran vorkommt.
Egal ob groß oder klein geschrieben. Macht das doch mal
ganz kurz. Wie oft? Ihr solltet es mir
nicht sagen, sondern einfach zählen und euch merken.
Ich mache es kurz selbst
So, ich hoffe, ihr habt es euch gemerkt,
dass es komischer ist. Nämlich, deswegen heißt die Klasse Psycho,
dass die Menschen sich da nicht so ganz einig sind,
wie viele Fs darin vorkommen.
Deswegen können wir mal eine Abstimmung machen.
Was sind denn mal realistische Werte? Vielleicht von 0 bis
9. Wer hat kein einziges 11 gefunden, meiner Hunter?
Keiner? Flatt nicht geguckt. Wer hat ein F gefunden
? Keiner, wer hat zwei Fs gefunden? Einer,
okay, wer hat drei Apps gefunden? Okay,
das ist grob über den Daumen, so ein Dutzend.
4 Fs
Das ist vielleicht so acht Leute. Fünf Fs? Das ist dann nochmal
so ungefähr 20, ich weiß es nicht, sechs Fs.
Okay, das ist vielleicht 25 oder so.
Sieben Fs? Ja, so zwei Reihe Leute.
Acht Fs. Ich glaube keiner, ne? Neun Fs
? Nee. Okay. Gut, wo ist denn hier
mal so der Hotspot? Also es wird wahrscheinlich irgendwas in
diesem Bereich sein. Drei, vier, fünf oder sechs.
Ich finde es mal toll, dass da so verschiedene Zahlen bei rauskommen.
Genau, man kann jetzt, ich habe ja hier unten,
Wie ist das implementiert? Ich rufe eine Hilfsfunktion auf,
zähle die Fs, wo ich diesen String einfach übergebe,
aber die ist noch nicht implementiert.
Hier wird einfach ein sinnloser Wert zurückgegeben.
Das testen wir einmal ganz kurz. Das ist ups,
das ist dieser sinnlose Wert, der auch wirklich zurückkommt.
Wieso kann ich das jetzt nicht kleiner machen?
So, da müsste also quasi 42 mal rauskommen.
Genau, das müssen wir also noch implementieren. Dann versuchen wir
das doch mal. Wir kriegen also einen String reingereicht.
Wir wissen, also ich weiß jetzt gerade nicht,
wie lange ist, aber das kann man ja fragen.
Wollen wir vielleicht erst mal als erstes fragen,
wie lange ist? Dann würde es man vielleicht lenden,
ist gleich s.lenks
Okay, jetzt wissen wir schon mal, wie lange ist vielleicht
so 50 oder so. Keine Ahnung. Wie kann ich
denn jetzt über jedes einzelne zeigen, diese Strings rüber iterieren?
Ja. Entweder vor euer weil, ich würde abwarten,
weil wir einen Regel kennen, einfach mal vor.
Und weiter. So. 0.0. Dienstleister. Sehr schön. Warum
machen wir das? Wir iterieren jetzt nicht über die Zeichen,
das geht so einfach in Javala nicht, sondern über die Positionen der Zeichen.
Also wenn der String, sagen wir mal,
50 Zeichen hat, dann würde ich jetzt iterieren über 0,
1, 2, 3, 47, 48,
49. Ich habe jetzt also in Schleifenrums Der wird jetzt so
oft ausgeführt, je nachdem, wie viele Zeichen da sind.
Habe ich jetzt die Position des nächsten Zeichens sozusagen an der Hand?
Wie komme ich denn jetzt an das nächste Zeichen?
Wie kann ich sagen, ich will jetzt das Zeichen an
der Position nie mal irgendwie haben und untersuchen?
Ja. Ja, wir können jetzt lasen, total erleben.
Chor at i. Dieser Ausdruck ist das Zeichen an der Position
Ihnen. Was wollen wir jetzt damit machen,
warum wir das irgendwo zwischenspeichern oder direkt irgendwie vergleichen oder so?
Ach, S.Charlette, ne? Richtig, wir müssen ja
den Stream vorher angeben. Okay,
also dieser Ausdruck ist das Zeichen an der Stelle über,
was machen wir denn jetzt mit diesem Zeichen?
Wir müssen ja irgendwas Sinnvolles damit tun, ja?
Da sehen wir jetzt einfach
die Frage
Okay. Das geht. Ich mache es mal der Übersichtlichkeit halber,
oder weil das für euch neu ist,
pue ich es meine eigene Variable.
Das muss man nicht, aber ich mache das jetzt einfach mal.
Und jetzt würdest du fragen quasi, wie fragt man das jetzt?
So? Ja, wobei das ist ja gleich.
Richtig, sehr schön. Wir wollen ja nicht zuweisen,
sondern vergleichen. Genau. Gut, das musst du dir noch,
oder der Großelter, ich warte, weil ich bin großartig gesehen.
Richtig. Wir müssen auch das große EF abfragen.
Das wird ganz gerne so gemacht
Nee? Nee. Geht wahrscheinlich nicht, ne? Ich lasse es immer,
ich lasse mich immer ganz gerne anmeckern vom Compiler.
Das ist so ein kleiner Fetisch von mir.
Bad Operan Tribes for Binary Operator oder, oder.
Okay. Er sagt also, dieser Operator braucht zwei bulolische
Operanten. Nur der linke Operant ist tatsächlich bullisch.
Hier kommt der True oder False raus. Aber du kannst
einen Bullin nicht mit einem Char verbinden mit dem Oder.
Das geht nicht. Man muss es also einfach nochmal vergleichen.
Da gibt es leider keine besonders tolle andere Schreibweise in Java.
Zumindest nicht in so einem IF-Direkt. Okay,
und was machen wir, wenn ich jetzt ein F
gefunden habe
Zählerworte. Wie heißt denn unser Zähler?
Es gibt noch gar keinen, ne? So,
ich habe keinen, habe ich nicht schon gesagt.
S? S gibt es auch schon. Ach, das
ist bei Alex. Ich nenne ihn einfach mal Zähler.
Und was mache ich dann mit den Zählern?
Zähler. Ja, oder so rum, das ist egal.
Mach keinen Unterschied. Okay. Man sollte ihn initialisieren.
Wollen wir wieder mal im Fetisch nachgehen? Variable zähler might
not of been initialized. Also er sagt, du hast
ja hier nirgendwo gesagt, was der Startwert von Zähler sein soll.
Dann sagen wir, es soll null sein
Jo, oh, noch ein Fehler. Ich habe an
dieser Stelle versprochen, wenn diese Methode komplett durchgelaufen ist,
liefert sie ein Int an den Aufruferzeug,
das machen wir hier aber nirgends.
Es wird ja nirgendwo ein Ergebnis zurückgeliefert. Java kann nicht
auf magische Art und Weise wissen, dass das das Ergebnis sein soll.
Wie sage ich das denn jetzt, dass das Ergebnis sein soll?
Kann man sagen, gut sein. Ja, Retranssailer,
ne? Also, liebes Java-Laufsatzsystem, was auch immer zur Laufzeit
in dieser Variante drinsteht, den Wert will ich zurückliefern.
Jetzt müsste der Compiler zufrieden sein, genau.
Das ist doch nicht schlecht, oder
Also nochmal ganz kurz zum Mitdenken. Wir gehen am Anfang
erstmal ganz pessimistisch davon aus, dass kein einziges Äfterin ist.
Und jedes Mal, wenn wir ein F finden,
erhöhen wir den Zähler und am Ende müsste da dann ja die Anzahl F drinstehen.
Warum? Weil wir über alle Positionen des Drinks rübergehen,
weil wir uns jeweils das aktuelle Zeichen an der Position angucken und dann schauen,
ob es ein kleines F und ein Großzäf ist.
Das ist doch nicht schlecht. Schauen wir mal,
ob es das macht, was wir wollen.
Wie kann ich das erreichen, dass ihr den Code auch seht?
So, ja. Ach, Quatsch,
falsches Objekt
Ah, das ist dieselbe Zahl, die geflüstert wurde,
bevor ich die Abstimmung gemacht habe.
Also das ist, glaube ich, ein ganz guter Hinweis.
Das hat auch die meisten Stimmen. Ja,
also rein demokratisch scheint das so funktioniert zu haben.
Ich bin auch der Meinung, dass es sechs sind.
Wir können ja einmal ganz kurz gucken,
ob wir diese sechs Fs auch tatsächlich ausfindig machen können.
Also hier ist das Erste. Hier ist das Zweite.
Hier ist das dritte. Hier ist das Vierte.
Die sieht man meistens nicht, diese Offs.
Hier ist das Fünfte. Und hier ist das sechste.
Also die Leute, die drei gesagt haben,
haben wahrscheinlich diese Offs einfach nicht gesehen.
Gut, jetzt will ich euch aber nicht nach Hause schicken,
ohne dass wir mal ein eigenes Switch gebaut haben.
Also man kann eigentlich immer dann,
wenn man Variable mit irgendwelchen Konstanten vergleicht,
kann man das eigentlich auch ganz gut mit einem Switch lösen.
Ich mache jetzt mal wieder Folgendes, ich kommentiere das mal hier aus,
dass ihr den Kontrast seht oder dass ihr jetzt vergleichen könnt, wupps.
Ich will kein If, ich will ein Switch.
Dann switchen wir doch mal. Ich switche über das Zeichen,
was wir uns gerade raus extrahiert haben. Und jetzt muss
ich ja sagen, welche Fälle sind für mich interessant.
Es gibt einmal den Fall des kleinen Fs.
Was will ich machen, wenn ich ein kleines F gefunden
habe?
Ich will
den Zähler hochzählen
Und was will ich machen, wenn ich ein großes F gefunden habe?
Gut, das soll auch der Zähler umgezählt werden. Jetzt bitte keine Spoiler,
wenn ihr schon seht, dass da irgendwas nicht stimmt.
Genau, der Quelltext ist sichtbar, das ist gut,
dann erzeugen wir uns wieder ein Objekt, bitte nichts verraten.
So, warum sind auf einmal 11 Fs in dem String?
Das ist auch so eine komische Zahl, vorher waren es sechs,
wenn das jetzt doppelt so viel gewesen wäre,
hätte man gesagt, okay, das kann ich mir irgendwie herleiten,
aber warum denn jetzt elf?
Irgendeiner, du hattest heute noch nichts.
Weil kein Break drin ist, richtig. Das müssen wir
uns noch mal ganz kurz klar machen.
Was bedeutet das
Jedes Mal, wenn wir ein großes F gefunden haben,
wurde dieser Code ausgeführt. Und jedes Mal, wenn wir
ein kleines F gefunden haben, wurde dieser Code ausgeführt.
Also, ein Case sagt, wo im Rumpf eines Switches soll es losgehen.
Und es wird erst aufhören, wenn das Switch vorbei ist
oder wenn ich auf einen Break stoße, vorher nicht.
Also die Tatsache, dass hier nochmal Case steht, ist völlig egal.
Das war so die naive Variante ist jetzt, ich mache hier
einfach die Breaks darunter. Hier braucht man es nicht unbedingt,
aber aus rein symmetrischen Gründen finde ich das ganz nett.
Dann müsste da das selber rauskommen. Und meistens gibt es
jetzt immer so ein paar fortgeschrittene Leute oder neue Hacker,
die erkennen, dass es auch einfacher geht.
Da kommt dieser richtige Wert raus. Kann man das auch vereinfachen,
anstatt zu sagen,
für das kleine F möchte ich den Zähler hochziehen und breaken
und für das große F möchte ich den Zähler hochziehen und breaken,
geht das irgendwie einfacher?
Ja. Ich habe dich akustisch nicht richtig verstanden,
aber ich glaube, du meintest das Richtige.
Ich lasse es mir vielleicht noch mal von jemand anders sagen,
ja. Ich glaube, du hast exakt dasselbe gesagt,
aber nur ein bisschen lauter. Genau. Wir schreiben die Cases
einfach untereinander und dann brauchen wir auch das Break nicht.
Jetzt dann nehme ich es einfach mal weg, was Spaß macht.
Das heißt also, wenn ein großes F gefunden wird, wird dieser Code ausgeführt
Und wenn ein kleines F gefunden wird, wird dieser Code ausgeführt.
Das ist doch genau das, was wir wollen. Also immer,
immer dann, wenn ihr mehrere Fälle habt,
bei denen genau dasselbe passieren soll, dann schreibt ihr diese Fälle untereinander,
ohne da irgendeinen Code dahinter zu schreiben.
Und unter den letzten Fall schreibt ihr dann das hin,
was passieren soll. Okay, ich finde das persönlich irgendwie
ganz nett, diese Lösung. Ich weiß auch nicht,
warum. Irgendwie gefällt es mir besser als diese If-Low,
so ein bisschen lösche ich die jetzt mal.
So. Habt ihr dazu noch Fragen zu dem Switch?
Ja. Wahrscheinlich gefüttert. Zu Text, er war,
da bleibt er, voll ungeerdet, er lebt,
okay, jetzt ist er Zeit.
Bei der ersten Worte,
die er meint
Du meinst, ah, hier ist es sozusagen.
Genau, das ist eine gute Frage. Was darf hier stehen
? Hier dürfen nur Literale stehen oder irgendwelche einfachen Rechnungen,
wo der Compiler schon weiß, was da für ein Wert rauskommt.
Wie das hundertprozentig hart spezifiziert ist, weiß ich nicht.
Aber du kannst da nicht Variablen hinschreiben zum Beispiel.
Also irgendwie sowas? Nee, nee, das ist nicht erlaubt.
Das geht nicht. Man kann Charles nicht mit dem Ruder
verbinden. Leider nicht. Okay, zahlt es um,
bis nächste Woche