Zu Beginn der siebten Vorlesung, Riri. Herzlichen Glückwunsch.
Nach der heutigen Vorlesung haben Sie die Hälfte der Vorlesung hinter sich gebracht.
Das ist heute sozusagen bergfest. Danach geht es bergab. Was impliziert,
dass es heute nochmal ein Stück weit bergauf geht,
aber auch nicht mehr als sonst?
Das war der erste Glückwunsch, den ich heute loswerden wollte.
Und der zweite Glückwunsch ist, müssen Sie Das überlasse ich
Ihnen, ob Sie sich da glücklich fühlen.
Jedenfalls wissen Fred und ich, dass wir für SE2
auch wieder den Auftrag haben, Ihnen was beizubringen.
Könnte derjenige, der gerade einen Jubelschrei ausgestoßen hat,
nach der Vorlesung bitte zu mir kommen.
Wir können schon mal über die Klausur sprechen.
So. Um Gottes Willen wird das aufgezeichnet
Ja. Was? Das ist über diese spontanen Reaktionen.
So, heute. Strukturierte Programmierung ist das Thema. Sie
erinnern sich sicher, dass ich letzte Woche davon gesprochen habe.
Ein Designziel für die Programmiersprachen, für moderne Programmiersprachen,
ist es mit einer kleinen Anzahl voneinander nicht ableitbaren,
also orthogonalen Konzepten ausgehend,
dem Programmierer alle Freiheiten zu geben,
seine Programme zu gestalten
Also die Idee, ich möchte es mit einer Programmiersprache leicht machen,
gute Programme zu schreiben versus sind die Idee,
die sich nicht durchgesetzt hat,
mit einer Programmiersprache es zu erschweren, schlechte Programme zu schreiben.
Das ist natürlich dann gleichzeitig auch eine Verpflichtung für Sie,
also die Verantwortung für gute, schlechte Programme.
Die liegt bei Ihnen. Wir werden heute so ein paar von den sogenannten Kontrollstrukturen,
die Sie ja auch schon über Carol so ein klein wenig kennengelernt haben,
wir werden das Thema in der bewährten Arbeitsteilung so ein klein wenig,
werden wir das verdichten.
Also was gibt es an Kontrollstrukturen
In den Programm, in den Programmiersprachen,
in strukturierten Programmiersprachen und Fred wird ihnen zeigen,
wie man das in Java umsetzt,
beziehungsweise auf welche Fußfallen man treten kann, wenn man diese Kontrollstrukturen verwendet.
Welche Kontrollstrukturen das sind, sehen Sie hier bereits,
also auf der Folie,
es geht um die Verzweigung und die Wiederholung und welche Variationen
von Verzweigung bzw. Wiederholung
man unterscheiden kann
Eine Vorbemerkung zu den Kontrollstrukturen. Achso, ich habe jetzt
gerade diese Folie übersprungen, die habe ich vergessen rauszunehmen.
Also die Folien, die ich hochgeladen habe, sind wie
immer erheblich viel umfangreicher. Eine Vorbemerkung zu den Kontrollstrukturen.
Das sind die sogenannten zusammengesetzten Anweisungen oder auch Blöcke genannt.
Das wird sich nach, das werden wir im Laufe der Vorlesung,
werden wir das so an der einen oder anderen Stelle,
wird uns das noch begegnen.
Was hat es mit diesen zusammengesetzten Anweisungen
so Aufsicht
Haben bisher kennengelernt, dass sie so in der Sequenz einzelne Anweisungen hintereinander schreiben können.
Und die wurden dann, das bleibt auch so,
einzeln hintereinander ausgeführt. Mit dem Sprachmittel der Blöcke,
wie das hier durch dieses Beginn und End geklammert ist,
wird es möglich, einzelne Anweisungen so zu klammern,
dass sie eine Einheit bilden.
Das wird also gerade bei den Verzweigungen und bei den Schleifen,
die wir im Weiteren behandeln werden,
wird es eine Bedeutung haben,
insbesondere um die Übersichtlichkeit von zusammengesetzten Anweisungen
Das If-Statement und das Wide und die verschiedenen Schleifenanweisungen gehören dazu,
um die optisch und auch inhaltlich besser zu strukturieren.
Die Geschichte dieser zusammengesetzten Anweisungen ist also vergleichsweise alt,
also wir sehen hier so ein paar von diesen klassischen Programmiersprachen,
sollten sie wenigstens namentlich kennen, also zunächst die allererste Programmiersprache,
die dieses Konzept der zusammengesetzten Anweisungen verwirklicht hat,
implementiert hat, weil die Sprache Allgäu 60,
Allgäu ist so kurz für Algorithmik, Language 60 steht für 1960
Da wurden diese zusammengesetzte Anweisung so durch einen Beginn und ein End geklammert. Heutzutage in fast,
also fast nicht in allen, aber doch in den gängigen,
also gerade in den objektorientierten Programmiersprachen,
also ist das etwas weniger geschwätzig, fasst man sich eher kürzer,
werden diese zusammengesetzten Anweisungen hier auch Blöcke genannt,
durch öffnende und schließende geschweifte Klammern gekennzeichnet.
So ein Beispiel dafür sehen Sie hier,
dass also hinter diesem bullschen Ausdruck steht jetzt zusammengesetzte Anweisung und die Bedeutung ist dann,
dass nach, also der Erfolgreichen, das ist ja der Van-Teil nach,
also dem erfolgreichen Überprüfen dieser Bullshen-Bedingung, wenn also diese Bedingung wahr ist,
dann wird diese Anweisung insgesamt ausgeführt.
Also nicht nur eine Anweisung, die,
wie sie das vielleicht bisher verwendet haben,
sondern es wird dieser Anweisungsblock als eine Anweisung betrachtet und die
darin enthaltenen Anweisungen werden dann ausgeführt.
Sie sehen hier schon eine weitere Möglichkeit,
die sie in zusammengesetzten Anweisungen in Blöcken haben
Können sie sogenannte Blog-Lokalen Variablen deklarieren. Also Variablen,
die sie nur innerhalb dieses Bloges verwenden können, die an anderen Stellen des Programms keine Gültigkeit haben.
Kommen am Ende der Vorlesung nochmal dazu,
so etwas umfassendere Äußerungen zum Thema Sichtbarkeit von Variablen,
was sie sich an dieser Stelle merken können, ist,
dass innerhalb von Blöcken haben sie die Möglichkeit, solche Variablen zu,
also lokale Variablen zu deklarieren und dann innerhalb des Blogs zu verwenden,
so wie hier,
um also einen Switch zwischen A und B vorzunehmen
So, jetzt kommen wir zu diesen Kontrollstrukturen, die in strukturierten Programmiersprachen
zur Verfügung stehen. Und das Erste, die Erste,
die wir hier etwas näher betrachten, ist die IF-Anweisung.
Also die Verzweigung beziehungsweise bedingte Anweisung. Die hat generell folgende,
generell halt die folgende Syntax. Nach dem IF stehen also diese literalen Symbole,
die klammern und innerhalb der Klammer muss eine Bullshit Expression stehen.
Und nach der Expression kann Da entsteht auf jeden Fall ein Statement und dieses Statement kann jetzt,
also diese Anweisung, kann insbesondere auch ein Blog sein,
also eine zusammengefasste Menge von Anweisungen, gefolgt von einem optionalen Else-Statement,
die eckigen Klammern hier stehen für, dass dieser Anweisungsanteil optional ist.
So die klassische Form oder nicht die klassische Form,
so die einfache Form, ist die hier,
dass die Bedeutung davon ist, also wenn, ah,
kleiner SBs,
wird das hier ausgeführt und ansonsten wird der Else-Teil ausgeführt.
Soweit, so klar und man denkt so,
jetzt ist eigentlich alles gesagt dazu
Probleme, tauchen dann also etwas später auf,
beziehungsweise wenn man sich so mit etwas komplizierteren,
also nur etwas komplizierteren Anweisungen mal auseinandersetzt.
Wir haben hier schon gleich, also die entsprechenden Symbole verwendet,
damit es auch ganz deutlich wird, an welchen Stellen etwas gefährlich ist.
Jetzt schauen wir uns mal diesen Coach-Schnipsel hier an.
Der kommt ja so scheinbar so strukturiert und wohlgeformt,
kommt er daher. Wenn man sich mal,
und dann liest man sich das mal durch und fragt sich also,
welche Bedeutung hat denn jetzt, ich hasse es,
welche Bedeutung, Vielen Dank.
Welche Bedeutung hat denn jetzt dieser Code? Insbesondere die Frage,
zu wem gehört jetzt eigentlich, zu welchem If-Statement gehört eigentlich
jetzt dieses Els? So wie das hier eingerückt ist,
erweckt es ja den Eindruck, dass es zu diesem If-Statement gehört.
Das hat aber dann eine andere Bedeutung, als wenn dieses Els-Statement,
also zu diesem If-Statement gehört. So könnte man,
können Sie dann gerne auch mal ausprobieren,
wenn Sie Da ihr Blue Jay anwerfen,
sodass hier ist eine optische Täuschung, der im Compiler ist,
das ist ungefähr so ein gutes Beispiel wie das,
was Fred letzte Woche gezeigt hat, mit dem Operator ungleich.
Weil wenn man da einfach die beiden Elemente des Operators vertauscht,
dann sieht es anders aus, als dass der Compiler dann tatsächlich interpretiert.
Und das ist eben der Fall, der Fall auch hier. Deswegen,
jetzt komme ich zurück zu den Blöcken, ist es extrem hilfreich,
wenn man sich, also so wie das hier ist,
derselbe Code, wenn man das sprach, Nachmittelblock verwendet,
weil dann kann man nämlich also durch das Setzen von Beginnenden und Endenden klammern,
kann man ziemlich klar ausdrücken.
Also zu welchem, welche Bedeutung dieser Code eigentlich haben soll. So,
wenn sie sich das hier mal anschauen, dann denke ich,
wird die, dann liegt die Bedeutung,
die dieser Code hat mit dem optischen Eindruck,
liegt sehr viel näher zusammen, als das hier der Fall ist.
So, jetzt gucken wir uns das mal an und jetzt,
also ich bin ja Informatiker, will heißen,
Ich bin erstens farbenblind und zweitens habe ich also mit Geschmack und so habe ich eigentlich auch wenig Vertrag.
Wenn ich dieses Beispiel drei nehme, auch keine Ahnung,
vom Knöpfchen, das,
was ich da so in dem Beispiel drei als Beispiel sehen,
wie so Coach strukturiert wird, hat den etwas größeren Zusammenhängen,
sieht es häufig so aus.
If than at, nein,
Ifland is then
If then, if then und das könnte ich jetzt noch eine halbe Stunde weitermachen.
Bis dann hier irgendwann, okay, hier ist also die Bedingung,
auf die ich hinaus wollte, ist eingetreten.
Ansonsten machen wir das, machen wir das,
machen wir das, machen wir das, machen wir das.
Bis hierhin ist es also mindestens bis hierhin. Ich hoffe,
das ist halbwegs erkennbar. Wenn Sie so einen Kaut sehen,
ist das also so eine typische Sägezahn-Technik, die Sie da anwenden.
Das heißt, der Programmierer versucht erstmal alle möglichen Vorbedingungen abzuprüfen,
bevor er tatsächlich das tut, was jetzt im Rahmen einer Methode,
immer einer Prozedur-Schrägstrich-Funktion tatsächlich zu tun ist. Und diese Struktur ist also,
das ist so von der optischen Seite her,
eigentlich ist das ganz nachvollziehbar, dass wenn sie,
da entwickeln sie dann nachher auch so eine gewisse musterhafte Erkennung,
wenn sie sowas sehen, dann wissen sie gleich, aha,
da hat jemand versucht, also möglichst viele Vorbedingungen abzuprüfen,
bevor tatsächlich in dieser Prozedur eine Aktion in Kraft wird.
Und wir werden uns SE 2 werden wir uns auch noch darüber unterhalten,
also wie man mit dieser Sägezahntechnik konstruktiv im Rahmen
eines Konzeptes namens Design by Contract effizient umgehen kann.
So, also geschachtelte IF-Anweisung, das Mittel, Sprachmittel,
Blöcke verwenden, um zu verdeutlichen, wer gehört hier eigentlich zu wem?
Hallo? Einmal der Wurm drin ist. Dazu haben sie auch,
Entschuldigung, es war jetzt wieder zu weit,
die entsprechenden Quelltextkonventionen in ihren Unterlagen,
also die ihnen das auch nahelegen
Anmerkungen dazu noch. Im Rahmen der Übung könnten Sie jetzt den Eindruck gewinnen,
dass Sie zu 80 Prozent der Zeit in Ihrem späteren Berufsleben
damit beschäftigt sind, Code zu schreiben.
Und 20 Prozent Code zu lesen. Es ist eher umgekehrt
. In der Regel sind Programmierer damit nicht...
Doch, ich glaube, das kann man so sagen.
In der Regel sind Programmierer damit beschäftigt. Also sie kommen morgens zur Arbeit und nicht,
dass sie sich jetzt mit dickem Schädel fragen, was habe ich da gestern hingeschrieben.
Sondern die Situation ist eher die,
Sie arbeiten in Projekten und bevor sie Erweiterungen,
Veränderungen an Kaut vornehmen, sind sie eine ganze Zeit lang damit beschäftigt,
Kaut zu lesen, um dann an der richtigen Stelle hoffentlich,
also diesen Kaut zu erweitern.
Das heißt, sie tun sich und anderen einen großen Gefallen damit,
wenn sie diese Arten von,
also diese unter anderem dieser Art von Quelltextkonvention einhalten.
So, jetzt habe ich gesprochen über die bedingte Verzweigung und
ich habe letzte Woche darüber gesprochen, gerade habe ich es nochmal erwähnt.
Kleiner Ansatz von orthogonalen Konzepten. Ein Bruch mit dieser Regel
ist die Switch-Anweisung
Also man kann sich ja durchaus fragen,
also wenn man so zehn, zwölf,
zwanzig Werte hat und man muss das immer abfragen und man kommt also sehr lange,
also nicht zu einem, nicht zu einem Ergebnis beziehungsweise man weiß eigentlich ziemlich genau,
dass man nur eine bestimmte Menge von Fällen unterscheiden will,
dass man dafür ein etwas einfacheres, also syntaktisch so angemesseneres Mittel verwenden möchte.
Genau dazu ist jetzt diese Switch-Anweisung geschaffen worden, also eine Anweisung,
die Eigentlich abbildbar ist auf die IF-Anweisung, aber durchaus praktisch sein kann,
wenn man zwischen verschiedenen, benannten, bekannten Alternativen unterscheiden möchte.
Die allgemeine Form dieser Switch-Anwendung sehen Sie hier.
Also hier steht wieder eine Expression und das kann in Java,
also die Unterscheidung, in welchen Fall man eintritt,
kann, also ist jetzt hier kein Bulien,
sondern man kann hier zwischen, also Literalen unterscheiden,
also im Wesentlichen Charactern und Intager werden gerne verwendet und das,
was sie hier sehen,
ist auch noch
zwischen Elementen von Aufzählungstypen
So, die Bedeutung dieser Anweisung ist dann,
diese Expression wird ausgewertet und je nachdem, welchen Wert diese Auswertung hat,
wird also in dieses Statement oder in dieses Statement verzweigt.
Das heißt, man hat ganz einfach die Möglichkeit, verschiedene Fälle, also auf einen Fall oder bei einer Gelegenheit zu unterscheiden. Dieses Switch-Statement so hübsch das ist,
also so hübsch das zunächst mal ausschaut,
also hier steht auch nochmal, dass es eine Mehrwegverzweigung ist,
so hübsch wie das ausschaut, so gefährlich ist es auch,
ich zeige eben nachher nochmal ein relativ aktuelles Beispiel,
das auch durch die Presse gegangen ist, weil die Fragen,
die sich so im Zusammenhang mit diesem Cason,
mit den einzelnen Cases hier stellen, ist,
was passiert eigentlich,
wenn also diese Expression hat als Ergebnis ergeben hat,
dass die Value 1 rauskommt.
Dann werden also diese Statements, dieser Blog von Statements gegebenenfalls wird dann ausgeführt.
Ja, und dann, was passiert dann? So wie das hier steht,
werden dann die Statements 2 ausgeführt und dann gibt es einen Break und das bedeutet,
es wird hinter diesem Blog der Code weiter ausgeführt.
Die Frage ist, dann muss man hinter jedem dieser einzelnen Cases vielleicht einen Break machen,
damit es hier hinter, damit die Code-Ausführung hier weitergeht.
Das heißt also, mit dem Switch-Statement haben sie zwar einen Mehrwegverzweigung,
aber der Fall, in dem sie das einsetzen,
der wir im Vorhinein ziemlich genau überlegt werden.
Hier sehen Sie jetzt so ein weiteres Beispiel,
ein echtes Beispiel mit, also Sie sind das hier,
also abhängig von einer gedrückten Taste soll also eine bestimmte Aktion erfolgen.
Wenn also die gedrückte Taste A ist, dann soll das hier passieren.
Und hier weiß man halt, naja gut,
dann habe ich das also getan und dann soll ich halt hinter dieses Case-Statement verzweigen.
Wenn ich das jetzt hier nicht hinschreiben würde,
würde der Spieler erstmal nach links gehen und dann würde er sich wieder nach rechts bewegen.
Es passiert also gar nichts. So, das sind so die,
was da noch so alles an Problemen bei diesem Switch-Statement auftreten kann oder an,
sagen wir mal, unerwarteten Effekten dazu nachher noch ein paar Beispiele.
Jetzt haben wir die, also Sequenz,
brauchen wir nicht weiter drüber sprechen, das ist eh klar.
Wir haben also zwei Arten von, upsala, Entschuldigung.
Ja, aber auch bei den Cases, das ist Bedingung,
als jemals kann ich sagen, Switch in True, dann bei den festen Bedingungen.
Ich weiß, also die Frage war, muss man gucken,
ob ich diese Frage so überhaupt wiederholen kann.
So wenig habe ich die verstanden
Ob man in den einzelnen Switch-Cases, ob man hier auch eine Bedingung angeben kann?
Weil das bei TAP kann ich zum Beispiel sagen,
ich schreibe rum, Switch von dem geschweift, was aber tut.
Also wenn wir gefunden haben, ja.
Und bei den Cases kann ich dann zu dem Punkt angehen.
Ich kann dann verleihen, das brauche ich ja über ein Prozess.
Tun sie es nicht. Ja, ja. Wir sind
noch nicht so weit, dass wir über über Techniken,
der fortgeschrittene Techniken, der Programmierung hier sprechen. Das,
was ich Ihnen aber mit jetzt mittlerweile so um die 30 Jahren
Berufserfahrung sagen kann, ist ein Prinzip,
das sich wirklich bewährt hat und nicht nur in meinen 30 Berufsjahren ist.
Das heißt, KISS. Und das steht für Keep
it Simple Stupid. Und das ist deswegen so tragfähig,
weil ich möchte so wenig, also komplizierte Konstrukte einsetzen
wie möglich
Und dann kann man den Code besser lesen und er wird wartbarer. Und ein,
also wenn ich das wissenschaftlich, oder nicht wissenschaftlich,
also es gibt so etwas, das heißt,
kommen wir auch später noch drauf, das heißt, zyklomatische Komplexität.
Ups, ja, zu denken, ja, was denn?
Also um es kurz zu machen, man kann mit den Mitteln von,
man kann durch Betrachten eines Programms, welche Arten von Verzweigung,
welche Arten von Schleifen sind da drin, kann man also statisch ermitteln,
hoch ist die intellektuelle Hürde um diesen Kaut zu verstehen.
Da sind ineinander geschachtelte Switch und Case-Statements mit Schleifen,
also kann ich Ihnen sagen, also das erzeugt eine hohe, zyklomatische Komplexität.
Und das ist immer ein Zeichen dafür, dass dieser Code,
also zwar wahrscheinlich mit viel Gehirnschmalz geschrieben worden ist,
aber man muss eben auch viel Gehirnschmalz reinstecken und zwar unnötigen,
um ihn lesen zu können.
So, diese Balance gilt es zu halten und indem jetzt,
das war jetzt eine sehr lange Antwort auf eine kurze Frage,
Eine Sekunde belassen sie es dabei, dass hier,
also literalisch stehen Konstanten vom Typ Integer oder Charakter.
Ja, bitte. Von jetzt überbindest du uns gut,
Editor und einer, danke mal, nach einer Seite von Sina 4,
wobei es weitergegeben habe, könnte ich ja das Bedarf üben,
auch danke Schlüppen teilen.
Das wäre eine Ausführung, aber nicht wirklich hilft,
die da der Klatus hat, dann soll man,
dass der Weg auch, die nach vier Seiten treiben,
oder weil man daraus die fünf Teile sagt,
der da rüber treibt
Also ich würde Ihnen immer eher zur DIN A4-Seite.
Ich würde Ihnen immer eher zur DIN A4-Seite raten. Dann
sind wir schon zwei. Und jetzt gleich zeigt Ihnen Fred ein
unglaublich geiles Beispiel, wie ich etwas in drei Zeilen ausdrücken lässt.
Sieben. Sieben Zeit. Okay. Ja,
es gibt so, es gibt Programmierwettbewerbe,
also wie kann man also einen möglichst komplexen Zusammenhang in möglichst kurzer,
mit möglichst wenigsten Buchstaben ausdrücken
Aber das ist das Berufsleben des Informatikers,
also ist weniger von Programmierwettbewerben als von lesbarem Coachschreiben, gekennzeichnet.
So, jetzt komme ich zu den Schleifen. Es würde eigentlich ausreichen,
wenn man ein einziges Schleifenkonstrukt in einer Programmiersprache implementieren würde.
Diese Art von Wiederholungen braucht man eigentlich bloß eine einzige Art aus unterschiedlichen Gründen,
gibt es verschiedene Schleifenkonzepte und mindestens ein guter Grund ist,
also ich möchte Schleifen haben, von denen ich nicht weiß,
ein Schleifenkonstrukt haben, von das ich einsetze,
wenn ich nicht weiß, wie häufig wird diese Schleife durchlaufen.
Ein Beispiel dafür sehen Sie hier. Das ist die sogenannte Wildschleife. Und uns das mal angucken,
aha, hier wird also ein String mit dem Namen Passwort deklariert,
dann wird ein Benutzer aufgefordert, 1-1 einzugeben,
man liest es und dann, solange,
ich lese das jetzt einmal vor, was hier steht,
solange Also nicht das eingegebene Passwort gleich dem hinterlegten Passwort ist,
wird das also wiederholt.
Es ist ein Verhalten, das ist etwas anders als das,
was sie von ihrem gängigen Geräten kennen.
Also hier ist auch kein Zähler dabei, so nach dreimal
darf man nicht mehr. Diese Schleife hält sie fest,
bis sie das richtige Passwort eingegeben haben oder den Strom ausschalten.
So was anderes, aber das ist schon nicht mehr Teil der Schleife.
So, die andere Art von Schleife ist die Schleife,
die sie hier sehen, das ist die sogenannte Vorschleife.
Wenn man genau weiß, wie häufig man eine Schleife durchlaufen will,
wenn man genau weiß, Wie häufig der sogenannte Schleifenrumpf betreten werden soll,
dann wird man diese Schleife verwenden können.
So, was wird hier ausgegeben, naja,
die druckbaren Zeichen des Aski-Zeichensattes, was das ist,
haben wir in der letzten Vorlesung auch kennengelernt.
Das ist nur ein Beispiel. Ich komme jetzt gleich zu
der genauen Syntax dieser einzelnen Arten von Schleifen.
Grundsätzlich für beide Arten von Schleifen. Jetzt sehen Sie auch wieder
die Notwendigkeit, sich vorher nochmal kurz mit Blöcken beschäftigt zu haben.
Die Grundidee ist jeweils Es gibt eine Schleifensteuerung und diese Schleifensteuerung bestimmt,
ob der Schleifen Rumpf durchlaufen werden soll. Und das ist,
also das eine Grundprinzip und eigentlich wird es auch ausreichen,
also mit genau einer Schleifenkonstruktion, also sich hier zu begnügen.
Aber das ist jetzt dieselbe, dasselbe Argument wie der
Übergang oder das zur Verfügung stellen der Switch-Anweisung.
Es gibt einfach unterschiedliche Fälle von Wiederholungen, also will ich
dafür auch unterschiedliche Arten von Schleifen zur Verfügung stellen.
Also nicht beliebig viele,
sondern wie im Fall von Java halt genau vier Arten von Schleifen,
aber Im Prinzip würde eine reichen und nächste Woche das schon mal so als kleine, kleiner Ausblick auf die Vorlesung.
Nächste Woche werden wir uns mit einem Konzept namens Rekursion beschäftigen.
Da kommt man sogar ganz ohne Schleifen aus, um Wiederholungen auszudrücken.
So, die Zählschleife oder auch Vorschleife,
hier sehen Sie jetzt ein Beispiel in einer historischen Programmiersprache namens Java.
Dieses Beispiel wird auch Desktop Java, sag ich schon,
namens Pascal, Entschuldigung. So, hier sehen Sie jetzt so etwas,
so ein Stück Code, das ich total gerne zeige,
weil Auch wenn Fried ihnen gerne so Beispiele zeigt,
so eins plus eins und es ist nicht zwei.
Und da staunt der Laie und der Fachmann wundert sich.
Also man müsste wirklich mal eine empirische Untersuchung machen.
Also in wie vielen Fällen es für Softwareentwickler hinreichend ist
von 1 bis 10 zählen zu können.
Da wäre ich echt mal gespannt. Also meine Vermutung ist so
in 80 Prozent der Fälle aller Programme reicht es aus.
Also bis 10 zählen zu können. Und das erweist sich
nämlich schon als schwierig genug
Weil die Frage, die sich hier jetzt stellt,
so, die stellt sich nicht wirklich, ist,
wie häufig wird dieser Schleifenrumpf durchlaufen? Und ich wette,
dass da doch in den Übungen werden einige von Ihnen
demnächst damit... Es ist neunmal, es ist zehnmal,
es ist elfmal, so werden Sie da sitzen und sich fragen.
Und dann wünsche ich Ihnen jetzt schon viel Vergnügen dabei,
sich mit Schleifenbedingungen auseinanderzusetzen.
So, die Vorschleife in Pascal haben Sie jetzt gesehen,
die allgemeine Syntax der Vorschleife in Java, sehen sie hier oben.
Die erläutere ich jetzt gleich mal an ein Beispiel.
Also es gibt eine sogenannte Initial Expression.
Das ist eine Anweisung für die typischerweise dazu verwendet wird,
um also einen Zähler zu initialisieren.
Das ist also, hier wird eine Zählvariable I wird hier deklariert.
Denn hier steht der zweite Teil, ist eine Bulien Expression.
Das ist die Abbruchbedingung für die Schleife.
In diesem Fall I
kleiner Zeh
Dritte Bedingung ist oder das dritte Element dieser Vorsteife,
ist die sogenannte Update Expression. Und das wird die Frage beantwortet,
was soll hinter dem Durchlauf des Schleifen Rumpfes passieren? So,
wenn man sich das hier also durchliest,
wenn man das hier in deutscher Sprache ausdrücken möchte,
was da steht, wird da also,
ich deklariere mir eine variable I und deren initialer Wert sei null.
Solange dieses I kleiner Zehen ist,
führe bitte diese Anweisung hier durch und dann erhöhst du
das I um eins
Ja, und jetzt kann man anfangen,
also jetzt komme ich wieder zu meiner 9, 10, 11-Geschichte.
Hier steht jetzt also I, kleiner 10 und das I,
möge bitte, das ist ein Pri-Inkrement,
möge also so in dieser Art und Weise erhöht werden.
Und jetzt kann man sich fragen, oder warum nicht I,
kleiner gleich 10? Gucken wir doch mal hier,
weil hier wurde ja schließlich von 1 bis 10, also inklusive 10.
Diese Schleife hier fängt aber bei null an,
also muss sie möglicherweise, muss das tatsächlich kleiner 10 heißen.
Und warum steht hier plus plus I und nicht etwa I
plus plus
All das wird Auswirkungen darauf haben, eben genau,
wie häufig wird diese Schleife jetzt eigentlich durchlaufen.
Neunmal, zehnmal, elfmal, wenn sie es zwölf oder
achtmal durchlaufen wird, dann haben sie mehrere Probleme gleichzeitig.
Also von denen ich sie bitte, sie nur eins nach
dem anderen zu lösen. Ich kann mich daran erinnern,
dass ich so, als ich so in ihrem Zustand mich befand,
erst das zweite Semester, habe ich nur mal so aus Spaß versucht,
so eine Bundesliga-Tabelle zu implementieren.
Verdammt nochmal, also bei 18 Mannschaften ist der hatte,
ich hatte
immer 36 Spieltage
Kann nicht sein. Das weiß jeder,
der sich für Bundesliga interessiert, nach 34 Spieltagen ist Schluss.
Wo habe ich jetzt ein Problem in der Berechnung meiner Spieltage?
Da war ich irgendwie eine halbe Nacht mit beschäftigt.
Bis ich darauf gekommen bin. In diesem Sinne,
also sie werden nicht die Ersten und auch nicht die Letzten
sein, die sich mit diesem Problem herumschlagen.
Müssen wir alle mal so durch. So, welche weiteren
Schleifen gibt es, die Vorschleife haben wir jetzt schon kennengelernt.
Jetzt gibt es noch zwei Arken von Wildschleifen. Sie sehen auch in den Folien,
die sie sich eben aus dem Netz runterlagen können,
finden Sie noch weitere Erläuterungen hier zu diesem Charakteristicap positiv bedingt und abweisend.
Diese Schleife, nur das jetzt an der Stelle dazu,
heißt abweisend, also nicht, weil sie, die heißt abweisend,
weil möglicherweise wird, also der Schleifenrumpf niemals durchlaufen.
Das ist diese Schleifenart wird man also verwenden,
wenn man sich nicht sicher ist,
ob es überhaupt einmal dazu kommt,
dass dieser Statement,
dieses Statement-Blog
gegebenenfalls betreten werden soll
Die Dubile-Schleife machtest, also von der Syntax her genau umgekehrt.
Es wird mindestens einmal der Schleifenrumpf durchlaufen und dann wird überprüft,
ob er nochmal durchlaufen werden soll. Das heißt also,
mit diesen drei Konstruktionen, also sagen wir mal zweieinhalb Konstruktionen,
einmal der Vorschleife und den zwei Arten von anderthalb Arten von Waldschleifen,
das ist so,
damit können sie die unterschiedlichen Arten von Wiederholungen,
die sie realisieren möchten,
in Java implementieren
Ja, das ist jetzt keine besondere Art von Schleife,
die Endlosschleife, das ist typischerweise ein Programmierfehler.
Dann sitzen Sie vor Ihrem Rechner, es passiert nicht.
Es passiert wirklich nichts, ziemlich lange jedenfalls. Das sind
die Endlosschleifen, die man in Java ziemlich leicht programmieren kann.
Sie sehen das jetzt hier, so sind meist ungewollt und deshalb unbeliebt.
Nun ja, ich wollte das jetzt nicht weiter werten,
deswegen steht es da auch
ganz klein
Wild True, da wird sich niemals was dran ändern.
Also wird der Schleifenrumpf endlos wiederholt. Und wenn sie da
nichts tun, Fred, jetzt musst du mir mal helfen.
Wenn man da jetzt nur in den Schleifen Rumpf reinschreibt,
I wird zu I. Wie lange läuft denn das? Sehr
lange. Ich meine, es kostet auch keinen Speicher.
Aber noch? Ja, aber also das könnte ich sagen,
da vergeben wir mal eine Bachelorarbeit.
Lassen wir einfach jemanden drei Monate vorm Rechner sitzen.
Behaupten, das ist ein Experiment. Naja gut,
vielleicht auch nicht. So, die Endlosschleife wird also dann
unter anderem auch dazu verwendet. Das ist doch schön.
Apples Hauptquartier am Infinitive Infinite Loop Nummer 1. So, das
dazu. Jetzt immer mal wieder werde ich, werde ich,
werden wir in den Vorlesungen ihnen
auch berühmte Altforde vorstellen
Heute, Etzgar Deikstra,
der ist also unter anderem dafür berühmt geworden,
dass er so etwas über Testen gesagt hat,
was also so jeder Informatiker mindestens einmal gehört haben sollte,
dass man durch Testen nämlich immer nur höchstens die Anwesenheit von Fehlern beweisen kann,
aber nicht deren Abwesenheit.
Das ist also, wenn sie ein gut getestetes Programm haben,
können sie vielleicht sagen, also es sind keine Fehler anwesend,
aber sie können noch nicht sagen,
ob Fehler abwesend sind.
Das ist so
Testen gehen wir dann im Weiteren auch noch ein.
Er hat noch was anderes. Hat er für etwas anderes
, ist er ursprünglich berühmt geworden. Nämlich, dass diesen
Artikel geschrieben, überschrieben mit, das Go-To-Statement Considered Harmful.
So, jetzt habe ich noch überhaupt gar nicht über das Go-To-Statement gesprochen,
was das eigentlich ist. Und man kann auch in Java,
kann man also, gibt es das Go-To-Statement nicht,
so ganz tief unten in der Sprache,
ist es aber so, dass das als Schlüsselwort,
also reserviert ist, also mindestens ich weiß, weiß nicht,
zu welchem Zweck das als Schlüsselwort reserviert worden ist.
Ob die das vielleicht irgendwann nochmal auspacken wollen oder sie sich davor schützen wollten,
dass das also irgendwann doch mal in die Sprache eingebaut wird,
zu dem Zweck, zu dem es da,
zu dem es ursprünglich erfunden worden ist, nämlich für die unbedingte Verzweigung.
Das ist im Prinzip, ist das also das Go-To-Statement,
damit kann man alles programmieren. Das,
was Dicstra dazu aber gesagt hat, also als Kontrollstruktur,
das Go-To-Statement ist ausreichend, Im Gebrauch ist es etwas primitiv und das,
was man damit anrichtet, ist, also mass of once program,
also ein Haufen Unfug, den man damit anrichten kann.
So, jetzt erzähle ich Ihnen das und Sie denken,
was, Geschichten vom Krieg, so was soll das?
Damit kann ich in Java eh nicht verwenden. Naja,
es gibt also dann doch, sollen Sie hier,
das ist 1968, ist das also, ist das geschrieben worden.
Und vor drei Wochen war es dann, vor drei oder vier Wochen,
dass ich also über diesen Artikel hier gestolpert bin.
Und das ist nicht 1968, sondern das ist 2014,
das also so es bei der Implementierung, also von iOS,
wir sind dem da, dass es zu einem Problem gekommen ist.
Und sie sehen hier einen Ausschnitt. Ich glaube,
dass der Programmiersprache Objective C ist das,
in der gibt es diesen, der gibt es dieses Sprachkonstrukt.
Und das, was hier, die Details sind jetzt eigentlich egal. Das,
was hier passiert, ist, dass so offensichtlich nicht,
also diese Art von Sägezahlentechnik,
die sie ab heute verwenden werden, bei denjenigen,
die das hier implementiert haben,
bekannt gewesen ist oder die eine andere Art von weiß es ja nicht.
Schaut mal hier auf den Code drauf. Also weder ist also
die SE1-Programmierkonvention bei Apple bekannt. Sollen wir was dran tun.
Noch wird dieses Not-Wit-Vermiedendes, das Go-To-Statement verwendet wird,
wo doch schon Dikes 31968 gesagt hat, also liebe Leute,
lasst es, weil es führt also zu Effekten,
die ihr im Zweifelsfall nicht durchschaut.
So, das sind so die Aussagen über Kontrollstrukturen,
die ich heute machen wollte. Sie kennen jetzt also zwei
Arten von Fallunterscheidungen. Und Sie kennen drei Arten von Schleifen.
Und damit können Sie so, was die Programmierung im Kleinen anbetrifft,
haben Sie jetzt so das Vollständige Repertoire kennengelernt,
mit dem Sie Ihre Programme im Kleinen strukturieren können.
Ich möchte jetzt abschließend noch so zwei, drei Worte dazu sagen,
über sogenannte statische und dynamische Eigenschaften von Programmen.
Und da gibt es also zwei Themen oder zwei Begriffe,
von denen ich denke, denen wir denken,
dass sie die mal gehört haben sollten.
Das sind die Begriffe Sichtbarkeit und Lebensdauer
So, ich mache das mal gleich an einem Beispiel klar,
dass da, was sie da jetzt als Code-Beispiel sehen,
ist also diese klasse Test und da werden also verschiedene Variablen deklariert.
Die Frage ist jetzt so, auf wen bezieht man sich jetzt jeweils?
Also wenn man eine Variable anspricht, bezeichnet.
Gucken wir uns das mal kurz an. Es gibt hier
also eine Exemplarvariable vom Typ Integer mit dem Namen X.
Es gibt eine Operation, die heißt M1 und da wird
eine lokale Variable X deklariert. Die ist aber vom Typ Double
. Die könnte jetzt auch vom Typ String sein.
Könnte irgendwas sein. Und die erste Frage ist,
ist das eine korrekte oder ist das Programm syntaktisch korrekt?
Okay, diese Frage kann man mit Ja beantworten.
Und das, was man dazu wissen muss, warum,
also diese Art von Programm jetzt korrekt ist, ist folgendes.
Durch die Methode, durch die Operation M1 wird ein neuer Sichtbarkeitsbereich geschaffen,
in dem jetzt diese lokale Variable X, die Exemplarvariable X überdeckt oder verdeckt.
Das ist der Sprachgebrauch, der hier verwendet wird. Das heißt,
wenn Sie sich an dieser Stelle auf X beziehen,
beziehen Sie sich auf den nächsten,
deklarierten Kontext und das ist eben die Methode M1 in diesem Fall.
Wenn Sie sich in der Methode M2 auf X beziehen,
da spielt also die Sichtbarkeit von X innerhalb von M1 überhaupt keine Rolle.
Hier bezieht man sich dann auf den umgebenden Kontext und das ist wiederum,
also das kann an dieser Stelle nur die Exemplarvariable X sein.
Das ist so jetzt eine Idee zum Thema Sichtbarkeitsbereich. Wenn Sie jetzt noch hinzunehmen,
das ist jetzt in diesem Beispiel nicht drin,
durch Blöcke wird nochmal ein Weite, haben Sie die Möglichkeit,
nochmal einen weiteren inneren Sichtbarkeitsbereich zu schaffen,
indem Sie also nochmal mit demselben Namen eine neue Variable deklarieren können mit eigenen Sichtbarkeitsbereich.
Zeigt das mal gleich ein Beispiel hier. Das sind so
die Arten von Fehlern, die man mindestens am Anfang seiner
Programmiertätigkeit gerne macht. Das ist nämlich so das Versehentliche Überdecken
von Exemplarvariablen
So was sie sehen, also in dieser Klasse Uhrenanzeige sehen
sie also zwei Exemplarvariablen, die beide so vom Typ Nummernanzeige
sind und die eine heißt Stunde und die andere Minuten.
Wenn sie jetzt im Konstruktor dieser Klasse versuchen, diesen Variablen,
Entschuldigung, diesen Variablen hier Werte zuzuweiten und sich zuzuweisen,
sie schreiben das hierhin, bedeutet das,
sie deklarieren lokale Variablen Stunden und Minuten und weisen denen Werte zu.
Also sie erzeugen diese Objekte hier Und damit haben sie lokale Variablen
namens Stunden und Minuten deklariert und nicht etwa den Exemplar Variablen Werte zugewiesen.
Das wird Ihnen kein Compiler dieser Welt, so wird Ihnen das sagen,
weil der Compiler denkt sich vielleicht, der Dös-Baddle.
Wollte Exemplar variablen, einen Wert zuweisen, dass er das nicht geschafft hat.
Nun ja, Lernen ist halt ein schmerzhafter Prozess,
was sich Compiler halt so denken. So, und das,
was Sie eigentlich ausdrücken wollten, das sehen Sie hier,
nämlich Sie beziehen sich auf diese Exemplarvariablen und nicht etwa das,
was sie hier getan haben, nämlich eine neue Variable in dem Sichtbarkeitsbereich dieser Operation erzeugen.
So, mit Blick auf die Zeit nur noch ein Wort zur Lebensdauer.
Ich habe das jetzt auch nur, vielleicht dieser letzte Punkt hier.
Wir haben ja letzte Woche über das Erzeugen von Objekten
gesprochen und auch, also was das Zuweisen von Referenztypen bedeutet
So, was wie der Effekt, ein Effekt,
den sie erzielen können,
indem sie eine, indem sie Referenzen zuweisen, ist,
jetzt greife ich noch mal kurz zur Kreide.
Wenn das hier eine Objektreferenz ist, die erfolgreich auf ein
Objekt verweist und die hier tut es auch.
Und die soll mal meinetwegen A heißen und die heißt B.
Welchen Effekt wird wohl diese Operation haben.
A, wird zu B. Klapp, klapp, klack.
Also, dann wird doch wohl nachher alle zu B.
Auch die variable A, nicht mehr auf dieses Objekt zeigen,
sondern auf das Objekt, das auch bereits B verweist.
Jetzt ist die Frage, wie kommen wir jemals wieder an
dieses Objekt dran?
Das lebt noch
Wird jetzt aber ziemlich schnell zum Opfer eines im Hintergrund laufenden Prozesses.
Und das ist der sogenannte Garbage-Collector.
Der Garbage-Collector hat nichts anderes als die Aufgabe zu schauen,
dieses Objekt hier hat einen Referenz-Count von 2 und nach der Zuweisung A,
W zu B, dieses Objekt, einen Reference-Count von null.
Jetzt kommt der Garbage-Collector und sagt, jemand,
der nicht mehr erreichbar ist, der lebt zwar noch,
aber dass keiner merkt,
kann ich dem auch aus dem Hauptspeicher entfernen
Das ist hart. Das Java-Laufzeitsystem kommt mit einem eingebauten Garbage-Collector daher. Das ist eine Entscheidung,
die die Entwickler von Java getroffen haben,
die Aussage oder das Motiv dafür ist,
Garbage-Collection ist ein so lästiger Prozess, das braucht keinen Mensch machen,
sondern das überlassen wir einer Maschine, nämlich dem Garbage-Collector.
Das ist eine Entwurfsentscheidung, die man offensichtlich so treffen kann.
Java ist schließlich eine weit verbreitete Programmiersprache
Andere objektorientierte Programmiersprachen, namentlich C Plus Plus,
wo die Entwickler der Programmiersprache die Entscheidung getroffen haben,
Garbage Collection ist eine so wichtige Aufgabe.
Das kann nur eine verantwortungsvoller Programmierer übernehmen. Das heißt also,
in C Plus Plus kann es Ihnen passieren,
dass Ihnen der Speicher vollläuft, weil das räumt hier niemand ab.
Da müssen Sie sich halt selbst drum kümmern,
dass also die Lebensdauer von Objekten, die Sie nicht mehr,
scheinbar nicht mehr brauchen, dass die auch tatsächlich abgeräumt werden.
So, Dies ist jetzt der Moment,
wo für mich das Bergfest anfängt,
weil ich habe jetzt die Hälfte des Semesters geschafft und
Fred ist dann in einer Dreiviertelstunde auch vorbei.
Ich bleibe mit schönes Wochenende
Musik Schon mal kleiner Soundtrack, Check, Check,
Check. Ich muss aber noch
ganz viel laden
Musik Während ich meine Maus anschließe, könnt ihr euch ergötzen,
an dieser studentischen Lösung, die mir heute zugeschickt wurde,
wo also der Vorschlag zwei Sonnen zu implementieren umgesetzt wurde.
Und ich dachte erst, da hätte vielleicht jemand geschult,
das war so eine schöne Bahn bei rauskommt,
aber es ist tatsächlich alles
physikalisch korrekt
Ich bin begeistert. Vielleicht ein kleiner Applaus für diese zwei Sonnenlösungen.
Wobei ein bisschen wurde doch geschummelt. Ich habe mich gewundert,
wie kommt das eigentlich, dass diese beiden Sonnen,
die ja wahrscheinlich eine ziemlich große Masse haben,
dass die sich überhaupt nicht aufeinander zu bewegen.
Ich verschiebe das einmal in den Hintergrund. Das will ich mal einmal
ganz kurz angucken, ob da nicht doch jemand geschummelt hat.
Ach, leider steht hier auch nicht der Name des Autos.
Also das bin nicht wirklich ich gewesen.
Da hat jemand vergessen, den Autorennamen zu ändern.
Also schauen wir doch mal. Die Sonne hat die Masse 100,
die er, okay,
und die zweite Sonne heißt Mond
Okay, man sieht, hier wurde wahrscheinlich lange rumgespielt,
dass eine Clara rauskam, die so eine vernünftige Acht ergeben hat.
Sehr schön. Ha, welchen Sinn könnte das denn haben?
Normalerweise stand in dieser Methode ja nur diese beiden Zeilen.
Und jetzt stehen die da irgendwie sechsmal untereinander.
Welchen Sinn könnt ihr das haben? Ich habe mal
eine Idee, warum das der Student so gemacht hat.
Ja. Nee, das hat keinen physikalischen Gründe, ja.
Ja, die wechselt auch einmal ein. Genau,
es werden, die Simulation läuft jetzt sechsmal so schnell.
Wahrscheinlich wollte er einfach schauen, wie lange,
wir können uns dann einmal ganz kurz gucken,
welchen Unterschied das macht
Und das einmal so machen. Du hast immer noch auf der Kreisbaum.
Ob das jetzt, jetzt müsstest du theoretisch deutlich langsamer laufen.
Ja, genau. Sieht doch auch ganz nett aus.
Okay. Aha. Hier wurde geschummelt. Also die
Sonne und der Mond spüren jetzt überhaupt keine Einflüsse mehr.
Das heißt, die werden auf ihren Positionen verbleiben,
weil die Beschleunigung, die sie erfahren, immer null ist.
Alternativ hätte man das doch hier auskommentieren können.
Können wir auch mal gucken, was passiert,
wenn ich diese Schummelei einmal aufhebe?
Das könnte
sehr interessant werden
Hm. Ich lasse es mal im Hintergrund laufen.
Gut. Neues Thema. Ihr bekommt in der Übung ein Projekt,
das sieht so aus, ihr kriegt diese klassische Schleifendreher und die klasse Textanalyse.
Da sind schon schleifend drin programmiert. Und ich dachte,
wir können ja mal so einen Bruchteil von den Schleifen,
die hier drin schon programmiert sind, heute mal selber programmieren.
Das heißt, wir gucken überhaupt nicht, wie das hier implementiert ist,
sondern ich erzeuge mir mal hier ein Exemplar.
Und dann seht ihr, es gibt hier so ein paar
lustige Dinge. Zum Beispiel das Verlangen, Passwort,
das hattet ihr zum Beispiel schon gesehen,
gibt es hier, was haben wir hier noch?
Man kann irgendwie Divisionsreste berechnen, man kann irgendwelche Zweierpotenzen finden,
man kann ins inbinäre Strings umwandeln.
Toll, super spannende Sachen. Fangen wir mal mit
der einfachsten an.
Schreibe alle Ziffern
Macht also folgendes. Und ich mache jetzt einmal
die Option. Achso, die ist schon aktiviert.
Das ist immer ganz nett. Also jedes Mal,
wenn ich eine Methode aufrufe, wird die Konsole wieder komplett gelöscht,
dann bin ich nicht verwirrt, wann welche Ausgabe zustande kam.
Jetzt würde ich gerne ein Programm schreiben, was genau das
macht oder eine Methode schreiben, die genau das macht.
Gehe ich noch mal hin an meine eigene Klasse,
da würde ich jetzt sozusagen das alles nachprogrammieren.
Da haben wir jetzt also diese Methode,
schreibe alle Ziffern und ich möchte jetzt, dass sie sowas schreibt.
Und wenn man jetzt noch keine Schlafen kennt,
würde man das vielleicht so machen.
Schreib doch mal die Null auf die Konsole.
Dann die 1, die 2,
Ach, das macht nicht Spaß, muss ich sagen.
So. Ah, nee, stimmt gar nicht. Ha. Schon
der erste Programmierfehler. Das muss ja eine 9 sein.
Gut. Ja, und sollte ich das einmal ausführen,
dass wir sehen, dass es wirklich funktioniert,
mein Programm, was ich ja gerade geschrieben habe?
Guck mal, was jetzt exakt dasselbe macht. Ist das überhaupt
die richtige, doch schleifen, war die richtige Klasse?
Er macht also dasselbe. Okay, das sieht irgendwie nicht
so schön aus, oder? Irgendwie ist es zehnmal dasselbe,
was da steht, aber nur jeweils mit einer anderen Zahl.
Also irgendwie ist es doch so, hier steht eine Zahl,
nennen wir sie mal I, ganz unschuldig I,
was wäre denn ein sinnvoller Startwert für diese Zahl I,
wenn ich will, Also deklariere ich doch mal,
schöne, lokale Weible i und setze sie mal auf null.
So, und jetzt, ich fange mal am liebsten mit der Wire-Schleife an,
weil ich finde, das ist die einfachste, die man verstehen kann.
Hat jemand eine Idee, wie ich jetzt so eine Wire-Schleife schreiben könnte?
Also ich muss ja hier irgendeine Bedingung reinschreiben, irgendeine Schleifenbedingung.
Und dann schleife ich in den Schleifen rums,
ich schreibe in den Schleifen rum, das ist ein ganz schöner Zungenbrecher, das rein.
Was wäre denn jetzt eine sinnvolle Bedingung an dieser Stelle?
Da habe ich immer eine schöne Idee, ja.
E-Planer als 10, genau. Und das wäre jetzt ein Beispiel,
glaube ich, für eine Bachelorarbeit,
wo jemand davor sitzt und drei Monate wartet,
wann das Programm dann endlich mal zu Ende ist.
Was muss ich denn noch tun
Man muss schon wie... Irgendwie muss man
ihn noch um einen erhöhen. Wollen wir einmal gucken,
was passiert, wenn ich das nicht mache?
Also hier ist mein Programm oder mein Forschungsprojekt. Machen wir
doch mal. Schreibe alle Ziffern, da haben wir es.
Ja. Oh, mir fällt gerade auf,
dahinter sollte ja noch dieser Text, oh.
Ja. Okay, es geht ja zum Glück für notwendig
, hier diesen, diesen Notfallknopf.
Gut. Dahinter sollte ja noch mehr kommen,
da sollte ja stehen,
ist eine Ziffer,
ist eine Ziffer
So, dass man auch wirklich versteht,
vielleicht was der Sinn dahinter ist,
dass diese Zahlen da auf die Konsole geschrieben werden.
Ja, das machen wir gleich. So,
jetzt verstehe ich zumindest schon mal den Sinn des Programms.
Der Computer ist also der Meinung, dass neu eine Ziffer ist.
Okay, ich stimme überein und kann das immer noch nicht fließen.
Gut. Jetzt, ja, geht etwas los, das nennt man Bike-Shading.
Handro, wer weiß, was Bike-Shading bedeutet? Ja,
also man will irgendwie eine Hütte für sein Fahrrad bauen,
damit es nicht nass wird.
Und die wichtigste Frage ist, welche Farbe soll die Hütte haben?
Ja, das muss man als erstes klären.
Also schreibe ich jetzt hier hin plus plus i,
was schreibe ich denn i plus plus oder schreibe ich hier
ein i gleich i plus 1 oder schreibe ich ein i plus gleich 1?
Hast du viele Möglichkeiten? Was wollen wir nochmal nehmen?
Wollen wir abstimmen? Wer ist für plus plus
i, Handro
Oh, fast niemand. Vielleicht zehn Leute. Wer ist
für ePlus Plus, Handtuch? Oh, die Mehrheit.
Okay. I gleich ePlus 1. Ja, so ein paar, ja.
Und ePlus gleich 1. Okay, also die meisten wollten ePlus Plus.
Dann nehme ich mal Plus Plus 7. So. Das gefällt mir
nämlich am besten. Okay, schauen wir mal, ob
das funktioniert. Toll. Das Programm macht genau das,
was ich ihm gesagt habe, was er machen soll.
Okay. Das ist doch nicht schlecht, oder?
Wollen wir das noch einmal durchstemmen, dass wir die einzigen,
die einzelnen Schritte noch besser nachvollziehen können
Also ihr kennt das hoffentlich, habt ihr euch das schon mal gezeigt.
Wenn ihr in diesen weißen Bereich reinklickt, kommt da so ein Stoppzeichen.
Das kann man kaum lesen, aber da steht Stopp drauf.
So, und jetzt hält das Programm an. So,
und ich kann mich jetzt entscheiden, wann ich den nächsten Schritt machen will.
Ich bin bereit für den nächsten Schritt,
ich klicke mal hier drauf. Und jetzt seht ihr,
hier ist jetzt diese lokale Variable I erschienen mit dem Werten,
weil vorher war sie noch gar nicht da.
Jetzt ist sie erschienen. Okay, jetzt fragt sich
mein Computer, ist null, denn kleiner als zehn?
Ja, dann gehe ich mal in den Schleifen rumfreien. So,
jetzt möchte er dieses System out Printline ausführen und dann erscheint
hier wunderbar auf der Konsole, das neue eine Ziffer ist.
Toll. Ja, wie kriege ich das erstmal hier kleiner
Sich alles gleichzeitig sehe. So,
und dann soll das ihr erhöht werden, machen wir auch.
Jetzt hat es den Wert eins. Habt ihr gesehen,
wo du mal einen erhöht. Und jetzt ist was Spannendes
passiert. Jetzt ist er automatisch wieder hier hochgesprungen.
Das kennt ihr auch aus der Wahlschleife von Kerl.
Wenn der Schleifenhof einmal abgearbeitet wurde,
dann springe ich wieder hoch und muss die Bedingung prüfen.
Ist eins kleiner als zehn, ja, ist es auch.
Dann biebt er das eben auch aus. Und dann hört er
das ihn nochmal. Ich klicke jetzt mal hier ganz oft.
Ihr seht, das erhöht sich da so langsam.
Und jetzt wird es langsam spannender. So, jetzt hat I
den Wert neun. Neun ist sicherlich auch kleiner als zehn,
dann gehe ich hier rein, schreibe das neun, eine Ziffer ist.
Und jetzt kommt was Spannendes. Ich erhöhe ihn jetzt trotzdem
nochmal. Also jetzt wird I auf zehn erhöht,
obwohl ich zehn ja gar nicht ausgeben will
Und was wird jetzt passieren? Jetzt fragt sich der Computer,
ist zehn kleiner als zehn? Hier habe ich zehn und
hier habe ich zehn, das scheint irgendwie gleich viel zu sein.
Es ist nicht kleiner. Dann muss ich aus der Stleife
raussprengen. Zack. Und dann ist die Schleife beendet.
Okay. Gibt es bis hierhin erst mal Fragen zur Wirel-Schleife?
Ist irgendwas unklar in diesem Beispiel? Ja. Ja,
aber im Endeffekt, wir haben ja noch mal die andere Platte,
wo wir vielleicht 30 Jahre nötig und die Beine,
Gott hat das vor.
Genau, das wäre jetzt der nächste Schritt zu sagen,
das ist zwar schön, dass es mit so einer Why-Schlafe funktioniert.
Ja, im Prinzip ist da kein Unterschied bis auf die Syntax und
die Pragmatik. Also wenn ein Programmierer eine Wirel-Schleife sieht,
dann ist das Erste, was er denkt, ha,
ich weiß eigentlich gar nicht genau, wie oft die ausgeführt wird.
Also typischerweise schreibt man da sowas hin wie,
solange Kerl nicht vor einer Wand steht, sondern schon nach vorne gehen.
Bei solchen Problemen, wo ich sage,
ich fange bei null an zu zählen und zähle immer einen drauf,
bis ich bei einer bestimmten Zahl angekommen bin,
dann nimmt man normalerweise nicht die Wirel-Schleife, sondern die Vorschleife.
Und ich würde das Programm jetzt so umschreiben,
dass es eine Vorschleife verwendet.
Ja,
das mache ich einmal kurz mit euch
Also ich lasse die alte Version vielleicht einmal stehen,
ich kann sie ja auch mir einfach einmal kopieren,
kopiere ich mir einfach mal, nenne das mal irgendwie eins oder irgendwas dahinter.
Und jetzt mache ich daraus mal eine Vorschlafe. Das ist
ein recht einfacher mechanischer Prozess. Okay, ich sage,
ich schreibe einfach einen Fonds hier vor, einen Fonds hier vor.
So, dann schreibe ich als erstes, ja,
wie heißt denn mein Schleifenzähler, der heißt I,
von welchem Typ ist der und welchen Schlafwert soll er haben?
Das ist im Prinzip eine völlig normale Variablendeklaration, mit Initialisierung.
Gut, dann kommt als nächstes die Schleifenbedingung. So,
und jetzt kommt etwas,
was in den ersten fünf Minuten ein bisschen verwirrend ist,
das, was ganz am Ende des Rumpfs der Wildschleife dafür gesorgt hatte,
dass sich das I erhöht, was also logisch als letztes passiert,
schreibt man über den Schlafenrums.
Das ist etwas, was viele Programmieranfänger irgendwie ein bisschen verwirrt,
weil sie denken, naja, aber wenn das da drüber steht,
dann wird das doch irgendwie wahrscheinlich vorher ausgeführt, wird es aber nicht.
Ich werde das jetzt noch einmal kurz ausführen,
dass ihr also seht, dass es exakt denselben Effekt hat.
Da haben wir es. Ja, es macht also exakt dasselbe. Gut,
wenn man das jetzt durchsteppt, das ist ein bisschen schade,
Wie gesagt, immer dann, wenn du mehrere Möglichkeiten hast,
etwas zu schreiben, dann frage dich, was würde...
Ja, ein erfahrener Programmierer oder wie auch immer tun.
Also wenn du sagst, ich weiß genau, ich will,
dass die Schleife zehnmal durchläuft, bei null soll sie anfangen,
ich will in einer Schritte hochzählen, dann nimmst du eine Vorschlafe,
das macht einfach jeder Programmierer so.
Auch wenn es technisch anders geht. Ja,
also das ist so, wie man es normalerweise macht.
So, jetzt will ich da nochmal so ein Stoppzeichen setzen,
da ist es und will da auch nochmal durchsteppen.
Und das ist so ein bisschen schade, dass man da
die einzelnen Schritte nicht ganz so schön nachvollziehen kann wie bei der Wire-Schleife.
Schauen wir mal kurz. Also wir haben jetzt ja hier
Es wird jetzt ja sicherlich als erstes diese Initialisierung passieren müssen.
Dann wird er diesen Vergleich machen müssen, dann muss er
den Schleifenrumpf ausführen und dann muss er dieses Plus-Plus-I machen.
Also eigentlich vier verschiedene Zutaten hier. Schauen wir,
was passiert, wenn ich jetzt einmal Schritt über mache.
Oh, ihr seht, jetzt hat er schon zwei Schritte sozusagen gemacht.
Er hat also dieses I in die Welt gerufen und hat sich
auch sofort davon überzeugt, dass null kleiner ist als zehn.
Okay, dann führen wir einmal den Rumpf aus.
Jetzt landen wir wieder in dieser Zeile, der Blu-ray Debt-Debugger
ist halt Zeilen orientiert und er muss jetzt sicherlich das I erhöhen.
Das seht ihr, das hat er noch nicht gemacht.
Also sag ich mal Schritt über. Oh, und ihr
seht, ihr ist sofort wieder in den Schlafenrum reingesprungen.
Also die Tatsache, dass das hier ein eigener Schritt ist,
zeigt mir Blu-ray leider nicht an
Aber das Tolle ist, wenn ich das jetzt in mehrere Zeilen aufteile,
wenn ich das also so schreibe,
was man normalerweise nicht machen würde,
aber ich mache das jetzt einfach mal,
man will das ja im schönen Schritt weise nachvollziehen können.
Wenn ich das einfach so hinschreibe, dem Java-Compiler sind ja Zeilen völlig egal.
Und wenn ich das jetzt mal versuche zu debacken,
dann seht ihr, dass man das als Programmieranfänger viel leichter verstehen kann.
Also erst wird es das In-E gleich neu ausgeführt,
das will ich jetzt einmal machen. Dann habe ich ja
meine Variable E auf null. Dann prüft das schön in Ruhe,
ob null kleiner als 10. Ja, ist der Fall.
Dann macht er dieses System auch Printline.
Und jetzt erhöht er das E, das heißt,
es wird jetzt von null
auf einen springen
Das postet die Bedingung auch nochmal. Das sieht man also
viel schöner, was da jetzt in den einzelnen Schritten passiert.
Es wird nicht irgendwie diese Prüfung der Bedingungen sofort gemacht,
ohne dass ich sage, warte doch erstmal,
dass ich diesen Knopf gedrückt habe.
Vielleicht haben sich einige schon gewundert, warum das im Auslösungszustand
so komisch aussieht, diese Vorschleifen. Das ist eben der Grund,
damit man das schön schrittweise als Anfänger debatten kann.
Und wenn ihr dann später mal verstanden habt, wie diese Vorschleifen funktionieren,
dann würdet ihr das wieder alles in eine Zeile schreiben.
So. Okay, sehr schön. Das ist also das.
Was haben wir denn noch? Wie versaßen die Zweierkräfte
Ja, also, was kann ich hier hinschreiben?
Jetzt sind wir wieder bei meiner Fahrradhütte.
Da gibt es zum Glück gar nicht so viele Möglichkeiten.
Also ich könnte zum Beispiel schreiben, I ist gleich I plus 3.
Das wären zum Beispiel Dreierschritte oder das wären Zweierschritte.
Und alternativ kann man auch schreiben, wenn alles zu lang
ist, I plus gleich 2 geht auch.
Ja. Ja. Wie kommt das jetzt mal in ein Interview?
Letzte Schrittigkeit hat keine Drohnung. Weil das in der Syntax von Java
so definiert ist, dass da kein Simikol dann hinkommt.
Im tieferen Sinn hat es nicht
Ja, man hat drei Bestandteile, die durch zwei Semikola
getrennt werden, das ist einfach so festgelegt, ja.
Macht das jetzt wirklich eine andere Schrift,
aber wenn ich plus plus hier oder so plus schreibe.
Nein, das macht an dieser Stelle überhaupt keinen Unterschied.
Die Frage war, ob I plus plus und plus
plus ihr an dieser Stelle einen Unterschied machen.
Das ist so ein Thema, wo man unglaublich lange
drüber reden kann. Ich versuche das mal abzukürzen.
Also dieses Plus plus I ist ja ein Ausdruck, ne?
Was macht dieser Ausdruck? Er erhöht das I und anschließend
liefert er mir den neuen erhöhten Wert von I zurück.
Und wenn ich jetzt noch irgendwas damit machen würde,
wenn ich jetzt zum Beispiel sagen würde, X ist gleich plus plus I,
da der neue erhöhte Wert in dem X drin stehen.
Und wenn ich sage, X ist gleich iPlus plus,
dann würde i auch erhöht werden. Aber in dem X
würde dann noch der alte Wert vor der Erhöhung drinstehen.
Aber da ich hier diesen Ausdruck plus plus i nicht als Teilausdruck
eines größeren Ausdrucks verwende, macht es überhaupt keinen Unterschied.
Ja. Okay, was ist das nächste, was wir nachbauen wollen?
Das war jetzt so quasi die 90 Prozent Standardschleife.
Ich fange bei null an, solange ich nicht bei zehn
angekommen bin, erhöhe ich um einen.
So gehen 90 Prozent eurer Schleifen aussehen.
Haben wir hier zum Beispiel mal Schreibedreierze von rückwärts.
Ihr seht also jetzt hier, man fängt nicht bei null an,
sondern irgendwie bei neun. Und man zählt auch nicht hoch,
sondern man zählt runter und man zählt auch nicht in einer Stritten,
sondern in Dreierschritten.
Ja, und dieser Text soll dann jeweils ausgegeben werden.
Das können wir auch nochmal zusammen programmieren.
Das muss also sicherlich auch wieder eine Vorschleife sein.
Ich mache das jetzt einmal kurz so und dann können wir
gleich einführen, was da rein muss.
Was soll auf die Konsole geschrieben werden? I ist durch
drei teilteilbar. Ich will einfach alle ziffern, wissen,
die man durch drei teilen kann.
Und lustigerweise will ich mit der Größten anfangen. Gut,
was muss ich denn jetzt als erstes reinschreiben?
Also wie soll der Schleifenzähler heißen,
welchen Typ soll er haben,
welchen Start wert soll er haben
Du? Intridge habe ich gehört. Inti gleich? Neun
, hast du gesagt, ja? Gut. Was ist
denn, vielleicht machen wir hier mal weiter.
Wie soll sich denn das I nach jedem Schleifendurchlauf ändern?
Also erst ist es neun, dann ist es sechs,
dann ist es drei, dann ist es null,
seht ihr da irgendeine Regelmäßigkeit, ja?
Genau, I-Minus 93 hast du gesagt, sehr schön.
Und jetzt kommt vielleicht der schwierigste Part. Wie kann ich
denn jetzt entscheiden, ob ich nochmal rein soll in den Schleifenrum
Also welche Bedingungen gilt für die Neuen,
gilt für die Sechs, gilt für die Drei,
gilt für die Null, aber gilt anschließend nicht mehr.
Ja. Genau, I größer gleich Null, sehr schön.
Also das kriege ich jetzt, glaube ich, auch im Kopf hin,
da muss ich das Programm gar nicht aussehen. Also 9 ist ja größer gleich Null,
das heißt 9 wird ausgegeben und dann ziehe ich Drei ab,
dann habe ich 6. Sechs ist größer gleich Null,
dann gehe ich rein, ziehe drei ab,
dann bin ich bei 3, Drei ist größer gleich Null,
dann gebe ich es aus und ziehe drei ab,
dann bin ich bei Null, ist null,
größer gleich Null, ja,
wegen diesem Gleicherzeichen hier.
Das heißt, ich gebe die Null auch aus,
das heißt, welchen Wert hat das I theoretisch hier unten,
na gut, hier unten gibt es das eh nicht mehr,
also welchen Wert hat das I,
wenn die Schleife verlassen wird
Ja, null kann es nicht sein, denn null ist ja
größer gleich null, also muss ich in die Schleife rein.
Ja. Das hat den Geld auf Platz drei Wochen vorbei,
bereits der achte, der achte, der so da reinklickt.
Genau, wir müssen am Ende nochmal drei abziehen.
Sehr schön, ne? Also der Computer ist nicht so schlau,
dass er sich denkt, naja,
ich soll ja nur alle zahlen bis inklusive null ausgeben,
oh, wenn ich jetzt noch weiter subtrahieren würde,
dann würde ich ja da drunter landen,
dann mache ich das erst gar nicht,
sondern er muss diese Subtraktion wirklich machen.
Und dann prüfen ist minus drei größer gleich null?
Nö. Jetzt muss ich aufhören
Das ist also auch, da kommt man schnell durcheinander als Programmieranfänger.
Welchen wird halt E, wenn ich das letzte Mal hier
drin bin, welchen Wetter E, wenn ich rausgehe?
Da hat man immer diesen Plus-minus-eins-Fehler. Ja. Könntest du das,
nachdem diese Schleife für die Leute das überhaupt noch zugreifen?
Nein, das I ist,
nachdem ich dich die Schleife ausgeführt wurde, nicht mehr zugreifbar.
Das können wir einmal ausprobieren. I, ja,
was schreibe ich denn jetzt mal?
Erfüllt die Schleifenbedingungen nicht mehr. Und da wird sich jetzt
der Compiler beschweren und sagen,
ich kenne keine Variable
Schauen wir mal, was der Compiler sagt.
Let auf jeden Plus. Gut. Cannot Financible,
variable e. Also er schaut also nach, alles klar.
Ich bin ja gerade im Rumpf dieser Methode.
Ich bin ja gerade quasi hier. In diesem Blog bin
ich ja quasi. Wurde hier irgendwo ein E deklariert?
Nö. Warum nicht? Weil das E, was ich
hier deklariere, Entschuldigung, gehört ja nur in diesen Blog.
Oder wenn man so will, eigentlich, ja,
das ist so ein bisschen schwierig mit Blöcken zu argumentieren.
Sagen wir so ungefähr, ja. Das ist also
der Bereich, wo das Edem Compiler bekannt ist.
Da drüber und da drunter gibt es kein E. Ja.
Was könnte ich denn jetzt machen,
wenn ich auf das E trotzdem irgendwie noch zugreifen will?
Und dann hat da jemand eine Idee, ja
Das I-Feuer-Deckerin, das könnte man machen. Also wenn ich sage,
ich will das I bereits hier haben, im gesamten Rumpf der Methode,
dann darf ich sie natürlich nicht neu deklarieren,
sondern nur noch zuweisen.
Das ist so ähnlich wie das Beispiel von Guillos-Folie.
Dann geht das wieder. Und dann guckt also Compiler,
kenne ich irgendwie ein I, gibt es in diesem Blog
irgendwo ein I, alles klar, hier ist es.
Das können wir einmal ausprobieren. Also da müsste ja minus drei rauskommen.
Ja, minus drei. Und er ist aus der Schleife rausgegangen,
war minus drei eben nicht mehr, größer gleich neu ist.
Toll. Kennst du das mal vor,
mit I,
wenn es so läuft
Sorry, was soll ich machen? Du meinst hier?
Ah, in C plus plus geht das.
Ich glaube, in Java ist das nicht erlaubt.
Probieren wir es mal aus. Veryable E ist already defined
and methods schreibe 3er Zipfel von rückwärts. Das geht also
nicht. Ja, das finde ich gar nicht so schlecht.
Okay, ja. Aber ich hätte wetten sollen, verdammelt.
Gut. Wollen wir noch anmachen? Es macht auch so
Spaß, Schleifen zu schreiben. Vielleicht diesen einen noch,
weil der ist als Vorbereitung für die Übung
auch wichtig
Das ist ja spannend. Also wir haben jetzt also hier eine Zahl,
die irgendwie so hoch geht und hier war eine Zahl,
die irgendwie runtergeht und die Summe scheint immer dieselbe zu sein.
Also ich will irgendwie alle ziffern, wissen die oder alle Zefannpaare,
wenn ich die Ziffern addiere, soll neun rauskommen.
Hat denn da jemand einen Vorschlag, was da eine sinnvolle Vorschleife wäre?
Ich würde mir mal eine Idee, wollen wir den linken Zähler
irgendwie als Schleifenzähler nehmen oder den rechten oder wie beide?
Ja, wir künstlich beschreiben vor, dass wir dann gleich
Das ist der Kleiner 10. Zehn, okay.
Und... Okay, du willst also insgesamt zehn Zeilen auf die Konsole schreiben?
Nee, ne? Also man braucht irgendwie weniger,
oder? Ja. Aber was du machen könntest,
wir können nicht eine Zelle rausgeben und sagen,
die Ärzte, das sei dir ausgetötet.
Und die zweite Zelle ist im neuen Minus.
Das könnte man tatsächlich machen.
Das ist schon ein bisschen spannender als exakt die Lösung aus der Übung zu nehmen.
Also du sagst, ich soll I ausgeben und dann soll ich...
Ah, das mache ich jetzt mal absichtlich falsch.
So wäre das, ne? Toll. Sieht jemand einen Fehler?
Meiner sieht einen Fehler, ich warte mal ein paar Hände hoch.
Ach, immer dieselben Hände. Du? Genau, du hast gesagt,
Wir haben hier ein Int und wir haben ein String.
Was denkt sich Java, wenn es eine Addition sieht von
einem Int und einem String?
Es wird ein String daraus machen. Dann wird es,
ja, also das ist, das ist dann ein String
und dann kommt nochmal ein Int dazu.
Das heißt, dieser Int wird hinten rangehängt.
Das heißt also, dieser Ausdruck ist vom Typ String.
Und jetzt soll ich von diesem String E abziehen, das geht natürlich nicht.
Von Strings, irgendwelche Zahlen abziehen, macht überhaupt keinen Sinn.
Das heißt, das muss ich ja einmal klammern.
So, schauen wir mal, ob das funktioniert.
Natürlich werden da jetzt noch ein paar Zahlen zu viel ausgegeben,
aber das kriegen wir dann ja auch noch hin
Ist vielleicht sogar auch ganz hübsch. Ja,
das habe ich hier zehn Tage rausgegeben. Okay,
was müsste ich denn jetzt ändern, damit er sozusagen,
damit das hier die letzte Zahl ist, dir ausgibt,
dass er den Rest nicht mehr ausgibt?
Was müsste ich dann ändern, ja? Genau, kleiner Fünf,
ne? Warum kleiner Fünf? Also wenn ich diese Zahlen ausgeben will,
dann gilt ja für alle diese East 0,
ist kleiner als 5-1,
ist kleiner als 5-2, 3 und 4 auch.
Fünf ist nicht mehr kleiner als fünf,
also wird hier die Schleife aufhören, bevor ich das schreibe.
Ja? Toll. Okay, es wird also bei uns
ein bisschen anders gelöst mit zwei Schleifenzählern.
Das schaut euch dann vielleicht einfach in Ruhe an.
Okay, wie viel Zeit? Oh, oh Gott,
ich habe schon wieder überhaupt
keine Zeit mehr
Ich schaue kurz, dass ich noch vorbereitet hatte.
Ja, das muss ich überspringen, das überspringe ich auch.
Ah, hier vielleicht noch. Das ist noch so
ein kleines Rätsel, was ich immer ganz nett finde.
Ja, erst mal Frage Nummer eins. Welchen Sinn hat offenbar
diese Vorschleife? Ich könnte da irgendwie so einen Sinn hintererkennen.
Ja. Wir kriegen alle Werte aus, wenn die unternehmen kann.
Ja, also wenn ich jetzt hier hinschreiben würde,
System Optront and E, dann würde er alle Werte ausgeben,
die man mit dem In so annehmen kann, genau.
Okay, das ist also die Intention.
Tatsächlich ist es aber eine Endlosschleife. Hat jemand eine Idee,
warum das eine Endlosschleife sein könnte
Das ging recht schnell, die Hände hoch. Das freut mich.
Du hast lange nichts gesagt. Wenn ich in den Tagsbild
oder gehört habe, dann bin ich wieder beim Mini-Bay gehäusert.
Genau, also du hast gerade gesagt, wenn ich
diesen Wert hat, dann gilt ja sicherlich diese Bedingung.
Der größte, also wenn ihr den Größenwert hat,
dann bin ich halt leicht im größten Wert.
Dann gehe ich also hier rein, dann wird das ihr erhöht.
Dann habe ich wieder den kleinsten Wert. Und wenn ich
ganz oben ankomme, fange ich wieder ganz unten an.
Das ist diese Pac-Man-Logik. Und dann gilt diese Bedingung immer noch.
Das geht es aber noch einfacher, sich das zu überlegen.
Ich frage also, ob irgendein Int kleiner oder gleich der
größte Interest, den es gibt, Ja, natürlich.
Welcher Wert soll es denn sonst an einer mehr?
Geht doch gar nicht, ja. Mehr als der größte Infiat
geht nicht. Deswegen ist das eine Etwas-Schlafe. Finde ich
ganz nett. Okay, dann gehe ich mal weiter hier.
Wir geben euch noch eine weitere Klasse. Wir haben jetzt so
ein bisschen mit Zahlen rumgerechnet, das macht ja Spaß,
Ziffern ausgeben hoch und runter und irgendwie Summen von Ziffern.
Vielleicht kann man nochmal was Spannenderes machen und irgendwie mit Texten
irgendwas machen, mit Zeichenketten.
Wir haben also hier eine Methode, was macht diese Methode?
Sie nimmt einen String entgegen, hier diesen String nimmt sie
entgegen, String Text.
Und liefert mir True oder False zurück
Schauen wir, was diese Methode macht. Also, sie bestimmt erst mal,
wie lang ist denn dieser Text, der da übergeben wurde?
Ja, also offenbar gibt es eine Methode längst,
ihr könnt also auf jedem String die Methode längst aufrufen.
Wollen wir das mal ausprobieren, interaktiv in Bluegeas,
wenn diese Methode auf jedem String aufrufen kann?
Also, ich kann zum Beispiel sagen, hallo,
wie lang bist du denn?
Fünf. Toll. Und Welt, wie lang bist du?
Vier. Alles in Ordnung, verstehen wir.
Also, ich frage, wie lang ist der String?
Dann subtrahiere ich einen von dieser Länge. Das wäre also
bei Hallo, wäre es dann zum Beispiel vier.
Und dann gibt es eine weitere Methode,
die heißt Char-Ed
Man kann also einen String fragen, welches Zeichen steht in
einer bestimmten Position? Das probieren wir einmal ganz kurz.
Also ich nehme jetzt mal wieder Welt. Hey,
Welt, welches Zeichen steht denn an Position null?
Ah, da steht das W, alles klar.
Welches Zeichen steht denn an Position 3? Ah, da steht
das Tee. Welches Zeichen steht denn an Position 4?
Probieren wir einmal aus. String Index out of bounds Exception.
Ja, das ist wieder so ein Plus-minus-1-Fehler, den man
als Mensch gerne macht. Also die Länge ist zwar vier,
also es gibt vier Zeichen in dem String tatsächlich.
Ich kann sie erzählen, das sind vier Stück.
Aber die Position des letzten Zeichens ist drei,
weil ich aber null anfange zu zählen.
Es gibt nur die Position 0,1,2 und Teil,
das sind ja
vier verschiedene
Ja, toll. Und dann gucke ich halt,
welches das letzte Zeichen ist. Dann kriege ich ja so
einen Ciao. Und das ist auch interessant. Jetzt prüfe
ich, ob dieses letzte Zeichen ein Fragezeichen ist.
Ich mache einfach einen Vergleich zwischen zwei Chars.
Das letzte Zeichen, was ich mir rausgeholt habe.
Und das Fragezeichen als Literal. Und bei diesem Vergleich wird
jetzt True oder Fouls rauskommen. Und dieses True oder Fouls
speichere ich mir in dieser Variable namens endet auf Fragezeichen.
Diese Variable hat also jetzt entweder True oder Fouls als Wert.
Und dann gebe ich den Wert dieser Variable zurück.
Toll, das probieren wir doch mal aus.
Also ist Frage, sagen wir mal, oh Gott.
Ist das
eine Frage
Nö. Das ist keine Frage, weil hinten steht ja
kein Fragezeichen. Und dann probieren wir nochmal.
Na, nu. Ist das eine Frage? Ist auch
keine Frage. Da kommt zwar ein Fragezeichen drin vor,
aber es ist eben nicht das letzte Zeichen.
Gut, dann nochmal rum haben wir hier noch einen Test.
Wo war die Methode? Hier. Wie geht's? Ja,
das ist eine Frage. Also diese Methode soll euch zeigen,
wie kann ich herausfinden, wie lange der String ist,
wie greife ich auf einzelne Zeichen zu.
Ah, alles klar, das letzte Zeichen ist nicht die Länge,
sondern die Länge minus eins. Sehr schön. Und
darauf aufbauend Wollte ich jetzt mal was mit euch implementieren?
Es gibt einen wunderbaren String, ja. Das ist so
ein toller Psychotest. Also, schaut euch doch mal
irgendwie 10 Sekunden oder 20 Sekunden diesen String an hier.
Ups, ah, der muss schön sichtbar sein.
Und zählt doch mal, wie auf der Buchstabe F daran vorkommt.
Ja, gut. 10 Sekunden mal in Ruhe 10.
Wie oft kommt der Buchstabe F daran vor?
Und bitte nicht irgendwie reden währenddessen, das soll ja jeder
für sich entscheiden. Ich lese ihn einmal. Okay,
ich denke mal, jetzt sollte man es ungefähr haben.
Es soll ja auch irgendwie spannend sein.
Dann scrollen wir mal hoch. Machen wir eine Abstimmung.
Wer hat
überhaupt kein F gefunden
Okay, wer hat ein F gefunden?
Zwei. Drei. Ja, Handvoll, Leute.
Vier. Okay, auch noch ein paar, fünf.
Ah ja, das sind bis jetzt die meisten.
Ja, genau. Platz sechs. Ja, auch noch mal
ein bisschen mehr, sieben. Soll ich jetzt wieder auf
? Acht? Okay, es ist irgendwie so drei,
vier, fünf oder sechs, ne?
Und jetzt ist das Tolle, Menschen vertun sich offenbar,
sonst hätten wir jetzt alle dasselbe Ergebnis bekommen.
Ich kann dir den Computer bitten, das mal einfach zu zählen.
Ich habe so hier eine Methode geschrieben,
ich stecke ein String rein, die Methode heißt zähle die Fs.
Und es kommt dann in zurück. Ja,
das mache ich einmal
ganz kurz
Das eine Beispiel, hier, das war dieses Beispiel,
42 Fs, weil ich natürlich noch gar nicht implementiert habe,
was da passieren soll.
Okay, das müssen wir jetzt implementieren. Das ist schon
eine kleine Herausforderung. Wie kann ich mir denn jetzt jedes
einzelne Zeichen dieser Streams angucken? Oder jemand eine Idee?
Braucht was so eine Art von Schleife bei euch da?
Du. Ja, wenn wir da vorschleifen? Ja,
das ist halt ein Zeichen mit der längeren Streamingsätze.
Da könnte man jedes einzelne Zeichen für sich ansehen,
so wie wenn es im Erd ist,
bei unserem Ziel da schaut, dass man da fahrt.
Genau, also du hast eigentlich schon alles gesagt.
Ich hole mir einmal kurz vielleicht die Länge des Strings,
dann habe ich die schon mal,
dann wird die Schleifenbedingungen nicht
so kompliziert
So, jetzt werden wir ein bisschen konkreter. Kann man
ihm aber ganz konkret diktieren, was ich jetzt schreiben soll.
Int Iglas Neu. Also ich will an dem Zeichen Nummer 0
anfangen. Sehr schön. Ja. Ist euch egal.
Jetzt mache ich mal aus. Und ich bin ja hier
demokratisch, machen wir mal so vielleicht.
Ist völlig egal, was man da hinschreibt.
So. Wie oft wird denn jetzt dieser Schleifenrumpf betreten?
Wie oft lande ich hier drin? Ja. Du sagst
kleiner Gleichgang, konnte ich auch mal probieren.
Oh, nicht mal wieder eine Abstimmung. Wer ist dafür,
dass es kleiner innen sein muss? Ja, 20 Leute.
Wer sagt,
kleiner gleich ein
Ein bisschen weniger Leute. Wenn es kleiner gleich en wäre,
dann würde ich mir ja ganz am Ende einmal das Zeichen Nummer N angucken,
aber das gibt es ja gar nicht.
Wir haben ja gerade festgestellt, wenn die Länge vier ist,
darf ich nur bis drei schleifen.
Also kleiner ist schon richtig. Das erklären wir gleich.
Kleiner gleich N-minus eins, könnte man auch machen.
Wir können schon wieder über die Farbe der Hütte reden.
Sehr schön. Aber das ist so das Standardidium,
ja, kleiner als N. Okay,
jetzt gucke ich mir nochmal das Zeichen an,
was an der Stelle ist.
Ich nenne das mal vielleicht C oder Z wie Zeichen.
Wie komme ich denn jetzt an das Zeichen an der Stelle I?
Was muss ich da schreiben? Ob man
das Zeichen an der Stelle I ranzukommen
Ja. Genau. Ich bitte also diesen String,
hey, lieber String,
ich interessiere mich für das Zeichen an der Stelle,
i, gib mir das doch mal bitte.
So. Und jetzt? Ähm, bam, bam, du?
Ja, verdammt. Vielleicht, anfangs reich. Ja.
Ja, wir haben noch keinen selber, der...
Wir haben noch keinen Zähler, der die F zählt,
den mache ich mir immer ganz schnell,
ja.
In Fs
Ja. Plus plus Fs. Ah, ja. Es muss
null sein. Der Compiler wird sich hier beschwendet sagen,
ich bin mir nicht sicher, dass da ein sinnvoller Wert drin steht.
Schauen wir mal kurz. Genau. Ersatz mit möglicherweise
hast du vergessen, die Variable zu initialisieren.
Er ist da sehr vorsichtig in seiner Formulierung. Okay,
er will mir ja auch nicht auf den Schlips treten.
So. Genau. Sehr schön. Was wollen wir dann
statt 42 zurückgeben? Ja. So, toll.
Ach, ich liebe diese Aufgabe
Das ist leider die falsche Antwort. Fünf stimmt nicht.
Wie kann das denn sein? Wollen wir uns den String
nochmal ganz kurz anschauen? Fällt einem irgend... Fällt irgendjemandem
irgendetwas auf an diesem String? Ja. Wir haben jetzt
das kleine Exploit, das dauert nicht das Tode.
Genau. Und jetzt schreibe ich mal was,
was ich manchmal im Labor sehe. Wenn ZF ist,
in klein geschrieben oder F in groß geschrieben,
wird der Kompaller nicht akzeptieren.
Schauen wir mal kurz, was er sagt,
was das Typssystem sagt
Das Tüch-System sagt, also irgendwie gibt es ja Probleme mit den Operanten.
Also das ist ja ein Operator, der erwartet ja zwei Buliens.
Der eine Bulien steht auf der linken Seite, das ist wunderbar.
Im Vergleich liefert Jan Bulien. Aber F ist kein Gulien,
also F ist nicht irgendwie False oder so.
Das geht so nicht. Wie muss ich es denn schreiben?
Du? 4 Z Z Z, über das Z vielleicht.
Genau. Also es muss wirklich irgendein Vergleich oder irgendwas sein,
sonst wird das nicht funktionieren. Und ich klammere das mal ein bisschen schöner,
weil ja unser Quelltext, wenn wir jetzt nun sagen,
man soll immer schön klammern, dass man nicht verwirrt ist,
wie die Operatorpräzedenzen sind.
Okay, mal gucken. Und jetzt die richtige Antwort rauskommt
Ja, genau, 6Fs, toll.
Also die Leute, die sechs gesagt haben, lang richtig.
Ich kann euch doch verraten, wo das Problem ist.
Die meisten Fs, die man nicht sieht,
verstecken sich zum Beispiel, ah ja, hier,
da ist das eine, was ganz viele Leute übersehen.
Hier ist noch so eins. Und das hier wahrscheinlich.
Kann das sein, dass das hier noch manche Leute...
Ah, hier ist noch ein Auf. Ja,
also die Offs komischerweise erkennt man die nicht als F. Okay,
aber der Computer, der ist eben nicht auszutricksen.
Wir sagen ihm, schau dir jedes einzelne Zeichen an,
guck, ob ein F ist und dann macht er das auch.
Okay, dann wollte ich euch nochmal
was zeigen
Ah, verdammt schon, wie das die Zeit fast alle.
Aber egal, ich mache einfach weiter. Also,
dieses Switch, hat jemand eine Idee, wie ich
hier sinnvoll einen Switch einsetzen könnte, statt einem ist.
Ich finde das irgendwie blöd, dieses IF mit diesen beiden zusammenveroderten Teilbedingungen,
kann man das auch irgendwie mit einem Switch vielleicht machen?
Also, wie sah denn das Switch nochmal aus?
Switch sieht ja so aus. Ich switche über das,
was ich untersuchen will, das ist ja hier mein Set.
So. Und was stand in dem Switch drin?
In dem Rum, Fern? Genau, und dann gebe ich
den Case einfach an. Also, ich könnte sagen,
ich will so. So. Und in beiden Fällen will ich
ja sowas machen,
Ah, ja, die Leute stöhnen schon, das finde ich gut.
Schauen wir, was jetzt passiert. Huch? Elf Fs
? Wer sieht das Problem? Einmal Handtuch. Ah,
gut, okay, ihr habt die meisten um aufgepasst.
Okay. Einfach mal in den Raum schreien, was habe ich vergessen?
Genau. Das Break muss hier auf jeden Fall hin.
Bei dem letzten muss kein Breaking,
aber ich finde es konsistenter, wenn sie überall stehen.
Was war das Problem? Jedes Mal,
wenn ein kleines F gesehen hat, hat er erst dieses
Plus Plus Fs ausgeführt und anschließend dieses Plus Plus Fs.
Das ist natürlich Quatsch. Also die kleinen Apps hat er
doppelt gezählt. Gut, schauen wir nochmal,
dass das funktioniert
Moment, ich bin gleich bei dir.
So. Was hast du gesagt? Ich würde keinen Break entscheiden,
ich würde einfach das eine, ich nehme die an,
das einmal als Glück für mich.
Sehr gut. Wir können sozusagen diese Eigenschaft ausnutzen,
dass der Kontrollfluss einfach weitergeht, weil wir in beiden Fällen dasselbe machen wollen.
Also wenn irgendwie Java merkt, es handelt sich um ein kleines F,
dann muss ich also den ganzen Code auswählen,
der hinter diesem F steht, bis ich auf einen Break treffe.
Dann mache ich erstmal hier in dieser Zahl im Nichts,
kurz entspannen, was passiert als nächstes.
Dann soll ich diesen Zähler erhöhen und dann bin ich fertig.
Also er kommt dann sozusagen von hier.
Und wenn ein großes F findet, dann fängt er eben
hier an mit Code-Ausführung
Es geht auch nur, weil richtig immer ein Einzelne ist.
Sorry, nochmal. Wie geht jetzt auf einmal, weil
da war ein einziges Großes. Das probieren wir aus.
Also wenn ich jetzt zum Beispiel dieses F auch groß mache,
mal sehen, ob dann immer noch das richtige Ergebnis rauskommt.
Ich wüsste nicht, warum das jetzt einen Unterschied machen sollte.
Nö, ist genau dasselbe. Macht überhaupt keinen Unterschied.
Das ist ja so eine total gängige Praxis zu sagen.
Wenn ich für verschiedene oder für mehrere Fälle exakt denselben Code
ausführen will, dann schreibe ich alle Fälle untereinander weg.
Und erst bei dem letzten Fall schreibe ich hin,
was ich tatsächlich machen will.
Ja, das ist ganz normal. Also diese Labels,
geben nur an, wo innerhalb des Rumpfs,
soll ich denn anfangen mit der Ausführung?
Und diese Breaks sagen dann, wo soll ich aufhören mit der ausführen?
Das ist ein bisschen sehr komisch. Aber es ist so
. So, jetzt wollte ich euch noch mal zeigen,
was ich noch alles vorbereitet habe.
Dieser Kommentar hat mir zehn Minuten Zeit geraubt und ich kann
das leider nicht mehr mit euch machen.
So, wo war noch eine Frage? War noch irgendwo
eine Frage? Ja. Oh, das Sonnensystem läuft das
noch? Ja. Das ist interessant, ja.
Wir hätten mal zwischendurch reinschauen sollen. Okay, gut,
Zeit ist leider schon wieder vorbei.
Dann vielen Dank, bis nächste Woche