WEBVTT 00:05.220 --> 00:07.900 So, dann sind wir soweit, 14 Uhr. 00:08.060 --> 00:11.320 Hallo und herzlich willkommen auch zur heutigen Programmieren 00:11.320 --> 00:12.220 -Vorlesung wieder. 00:12.580 --> 00:15.900 Schön, so viele von Ihnen hier heute zu sehen. 00:16.020 --> 00:17.720 Ich hatte gerade eben schon ein Gespräch. 00:18.640 --> 00:20.900 Es ist in dieser Programmieren-Veranstaltung, gerade wenn man schon 00:20.900 --> 00:25.020 ein bisschen programmieren kann, natürlich immer ein bisschen schwer 00:25.020 --> 00:27.940 abzuschätzen, wann soll ich in die Vorlesung gehen und wann nicht. 00:28.060 --> 00:30.600 Wenn man ein bisschen programmieren schon kann, dann wird zum Beispiel 00:30.600 --> 00:33.920 etwas, das wir heute diskutieren, sowas wie While-Schleifen und If 00:33.920 --> 00:35.660 -Statements einem schon bekannt sein. 00:36.120 --> 00:39.300 Trotzdem möchte ich Sie natürlich dazu ermuntern, in die Vorlesung zu 00:39.300 --> 00:39.560 kommen. 00:41.640 --> 00:45.060 Oder falls Sie dann doch sagen, naja, das bringt mir nicht so viel, 00:45.380 --> 00:48.300 dann auf jeden Fall Zeit, mal in die Folien reinzuschauen, auch 00:48.300 --> 00:51.100 versuchen, in die Folien fürs nächste Mal reinzuschauen, um dann auch 00:51.100 --> 00:53.800 den Punkt nicht zu verpassen, wann Sie wiederkommen sollten. 00:54.400 --> 00:58.400 Also tatsächlich, wenn Sie programmieren schon können, dann ist If, 00:58.560 --> 01:00.100 While und so weiter für Sie nichts Neues. 01:00.100 --> 01:02.200 Ein bisschen was Neues wird auch in dieser Vorlesung drin sein. 01:02.620 --> 01:06.480 Aber bitte, falls Sie nicht kommen in die Vorlesung, schauen Sie sich 01:06.480 --> 01:09.760 genau an, anhand der Vorlesungsfolien, wo wir gerade sind, um den 01:09.760 --> 01:12.360 Punkt, wann Sie wiederkommen sollten, nicht zu verpassen. 01:13.560 --> 01:14.000 Genau. 01:14.820 --> 01:18.480 Heute in der Vorlesung soll es um sogenannte Kontrollstrukturen gehen 01:18.480 --> 01:21.760 und ich bette das Ganze am Anfang nochmal wieder ein in unser Bild 01:21.760 --> 01:24.800 hier, in unseren Advanced Organizer, mit den ganzen Themen, die wir in 01:24.800 --> 01:26.860 der Vorlesung besprechen werden. 01:26.860 --> 01:29.640 Ganz das Bild durchgehen werde ich jetzt nicht nochmal, nur ein 01:29.640 --> 01:29.980 bisschen wiederholen. 01:30.700 --> 01:33.540 Was haben wir in der ersten Vorlesung gemacht oder in diesem ersten 01:33.540 --> 01:34.160 Foliensatz? 01:34.600 --> 01:38.840 Da haben wir uns um die Methodik, Ausfüllen von Programmen, 01:38.960 --> 01:40.840 Kompilieren und Ein- und Ausgabe gekümmert. 01:41.520 --> 01:45.160 Dann haben wir auch in der ersten Vorlesung tatsächlich oder 01:45.160 --> 01:47.400 eigentlich der zweiten, wenn man jetzt die Erstsemesterbegrüßung noch 01:47.400 --> 01:51.220 mitzählt, über Klassen und Objekte gesprochen. 01:51.220 --> 01:54.680 Also eben dieses fundamentale Konzept in der objektorientierten 01:54.680 --> 01:58.420 Programmierung, anhand deren oder andessen Sie Ihre Programme 01:58.420 --> 02:00.480 strukturieren werden im Verlauf der Veranstaltung. 02:01.460 --> 02:04.880 Beim letzten Mal haben wir dann über Datentypen gesprochen und 02:04.880 --> 02:05.540 Variablen. 02:05.740 --> 02:09.660 Also hier oben, die Klassen kannten Sie schon als Datentype und beim 02:09.660 --> 02:11.600 letzten Mal haben wir dann auch über die primitiven oder die 02:11.600 --> 02:14.420 elementaren Datentypen gesprochen und haben somit die verschiedenen 02:14.420 --> 02:16.080 Datentypen jetzt mal kennengelernt. 02:16.500 --> 02:19.280 Und wir haben auch über Variablen gesprochen, was sozusagen Instanzen 02:19.280 --> 02:20.380 dieser Datentypen sind. 02:20.380 --> 02:24.900 Das sind Speicherbehälter, so kann man es sich vorstellen, wo Werte 02:24.900 --> 02:28.680 eben abgelegt werden können und die ich mit Zuweisung manipulieren 02:28.680 --> 02:32.920 kann und dann so eben dem Computer die Berechnungsvorschrift geben 02:32.920 --> 02:35.220 kann, die wir ja eben haben wollen. 02:36.420 --> 02:40.160 Wir haben auch über Objektidentität und Referenzen gesprochen. 02:40.740 --> 02:44.460 Das ist ein bisschen abstrakt, nicht ganz so leicht als Thema. 02:44.620 --> 02:46.940 Wenn Sie da jetzt sagen, ich habe eigentlich überhaupt nicht 02:46.940 --> 02:50.200 verstanden, wo das geht, dann schauen Sie sich das bitte nochmal an, 02:50.980 --> 02:53.160 diskutieren Sie es in Ihrer Lerngruppe, weil das schon ein Konzept 02:53.160 --> 02:56.280 ist, was eben wichtig ist, in der objektorientierten Programmierung zu 02:56.280 --> 03:00.220 verstehen und gerade diesen Unterschied dann auch Vergleiche mit 03:00.220 --> 03:03.860 gleich, gleich machen zu können auf verschiedenen Objektvariablen, was 03:03.860 --> 03:05.400 das bedeutet und was dabei rauskommt. 03:06.000 --> 03:09.060 Dazu muss man das eben mit Objektidentität und Referenzen gut 03:09.060 --> 03:10.460 verstanden haben. 03:10.460 --> 03:15.260 Genau, heute soll es dann weiter gehen um sogenannte 03:15.260 --> 03:16.540 Kontrollstrukturen. 03:16.900 --> 03:20.200 Das sind Schleifen und Verzweigungen im Speziellen, die wir uns heute 03:20.200 --> 03:20.820 anschauen werden. 03:21.340 --> 03:24.820 Und damit kann man sagen, nach der Vorlesung heute können Sie dann 03:24.820 --> 03:26.400 auch was Kleines programmieren. 03:26.600 --> 03:28.920 Also bis jetzt waren unsere Codeschnipsel ja immer noch relativ 03:28.920 --> 03:29.720 einfach. 03:29.840 --> 03:31.820 Man hat einer Variable einen Wert zugewiesen und vielleicht ein 03:31.820 --> 03:32.560 bisschen was gerechnet. 03:32.960 --> 03:36.220 Aber wenn wir jetzt auch Schleifen und Verzweigungen können, dann 03:36.220 --> 03:38.560 können wir eben auch in unserem Programm auf unterschiedliche 03:38.560 --> 03:41.860 Gegebenheiten in den Eingabedaten sozusagen reagieren und je nach 03:41.860 --> 03:45.460 Situation andere Abläufe dann sozusagen ansteuern. 03:46.420 --> 03:48.560 Und wir werden heute uns auch noch ein bisschen Ein- und Ausgabe 03:48.560 --> 03:50.680 angucken, insbesondere Eingabe über die Konsole. 03:50.800 --> 03:53.360 Das ist noch ein paar Folien, aber einfach jeder Vollständigkeit 03:53.360 --> 03:53.660 halber. 03:54.500 --> 03:57.460 Auf die nächsten beiden Folien nochmal, auch für Sie zu Hause nochmal 03:57.460 --> 03:58.420 nachgucken. 03:59.340 --> 04:01.340 Die Zusammenfassung der letzten Woche, ich habe es gerade schon 04:01.340 --> 04:04.160 gesagt, aber nochmal mit ein bisschen mehr Text und dann eben die 04:04.160 --> 04:06.420 entsprechenden Ausschnitte hier aus unserem Advanced Organizer. 04:07.120 --> 04:09.640 Und für heute jetzt nochmal ein bisschen ausführlicher. 04:09.740 --> 04:13.720 Die Lernziele sollen heute eben gehen um Kontrollstrukturen und ein 04:13.720 --> 04:14.660 bisschen um Eingaben. 04:15.300 --> 04:19.240 Bei den Kontrollstrukturen, bevor wir dann zu den Verzweigungen und 04:19.240 --> 04:24.460 Schleifen gehen, kommt noch ein Thema davor, nämlich die Begriffe oder 04:24.460 --> 04:29.080 die Konzepte, Ausdrücke und Anweisungen, was man da in Java darunter 04:29.080 --> 04:29.680 versteht. 04:29.680 --> 04:32.460 Und das Lernziel ist eben, dass Sie danach dann den Unterschied 04:32.460 --> 04:36.220 zwischen Ausdrücken und Anweisungen kennen, dass Sie danach dann auch 04:36.220 --> 04:39.860 Ausdrücke schreiben können, die Werte berechnen, und dass Sie 04:39.860 --> 04:43.420 Anweisungen schreiben können, die den Zustand Ihres Programms ändern. 04:44.540 --> 04:47.740 Dann kommen wir zu dem Eigentlichen, den Kontrollflussanweisungen. 04:47.940 --> 04:50.980 Da ist das Ziel dann, dass Sie die Kontrollflussanweisungen in Java 04:50.980 --> 04:53.360 eben kennen und in Ihren Programmen verwenden können. 04:54.160 --> 04:57.540 Zum einen, dass Sie Fallunterscheidungen mit if und switch 04:57.540 --> 05:01.120 programmieren können und dass Sie auch Wiederholungen mit den 05:01.120 --> 05:04.480 verschiedenen Schleifenanweisungen while, do while und for 05:04.480 --> 05:08.660 programmieren können und auch die Unterschiede dieser Anweisungen 05:08.660 --> 05:09.760 verstehen und kennen. 05:11.140 --> 05:13.320 Und dann schließlich noch, das kommt dann in den letzten paar Minuten 05:13.320 --> 05:16.960 der Vorlesung, wie Sie Schleifenausführungen mit dem sogenannten break 05:16.960 --> 05:19.660 und continue auch modifizieren können. 05:19.760 --> 05:23.180 Das ist ein bisschen ein kleinerer Punkt bei diesen 05:23.180 --> 05:24.380 Kontrollflussanweisungen. 05:24.380 --> 05:27.240 Und wie gerade schon gesagt, auch Eingaben werden wir uns noch mal 05:27.240 --> 05:30.120 kurz angucken, nämlich wie man über die Konsole Werte eingeben kann. 05:30.200 --> 05:33.960 Wir hatten ja jetzt in dem Beispiel bisher nur Eingaben über, also 05:33.960 --> 05:38.760 auch über die Konsole, aber beim Aufrufen des Java-Programms behandelt 05:38.760 --> 05:42.220 und dieses über die Konsole eingeben, Werte eingeben ist, wenn Sie 05:42.220 --> 05:46.520 quasi Ihr Programm gestartet haben mit Java Programmname, wie man dann 05:46.520 --> 05:49.940 während der Laufzeit des Programms noch weitere Werte eingeben kann. 05:49.940 --> 05:54.420 Genau, deswegen hier nochmal so ein Bereich Methodik ein- und Ausgabe. 05:56.480 --> 05:58.460 Gut, soweit auch schon der Überblick. 05:59.200 --> 06:03.460 Starten wir also ins Eingemachte und schauen uns erst mal, wie gesagt, 06:03.980 --> 06:05.760 Ausdrücke und Anweisungen an. 06:05.820 --> 06:08.260 Und wir fangen an der Stelle mit den Ausdrücken an. 06:09.540 --> 06:14.020 Ausdrücke in Java Programmen sind oder werden verwendet, um 06:14.020 --> 06:18.440 vorzunehmende Auswertungen zu beschreiben, also Berechnungen zum 06:18.440 --> 06:22.340 Beispiel oder auch Vergleiche, ob etwas größer oder kleiner sind. 06:22.440 --> 06:26.560 Das sind jeweils Ausdrücke, das sind Auswertungen, die der Rechner an 06:26.560 --> 06:29.420 dieser Stelle machen soll und die beschreibe ich eben mit einem 06:29.420 --> 06:30.460 sogenannten Ausdruck. 06:31.620 --> 06:33.960 Wie sieht das aus, wenn wir uns hier so ein paar Programmschnipsel 06:33.960 --> 06:34.560 anschauen? 06:35.080 --> 06:38.680 Zum Beispiel steht auf der rechten Seite einer Zuweisung jeweils ein 06:38.680 --> 06:39.120 Ausdruck. 06:39.240 --> 06:41.260 Also wenn ich, wenn X jetzt eine Variable ist, zum Beispiel eine 06:41.260 --> 06:45.300 Integer -Variable und ich schreibe X soll zugewiesen bekommen und 06:45.300 --> 06:49.100 dahinter steht zum Beispiel I++ oder sowas, dann ist dieses I++ ein 06:49.100 --> 06:50.040 sogenannter Ausdruck. 06:51.600 --> 06:54.140 Ausdrücke finden Sie auch als Argumente von Methoden. 06:54.540 --> 06:57.380 Methoden kennen Sie bis jetzt die Main-Methode, noch nicht viel mehr, 06:57.480 --> 06:59.500 da kommen wir beim nächsten Mal dann nochmal zu, aber der 06:59.500 --> 07:00.640 Vollständigkeit hier auch. 07:00.960 --> 07:03.520 Wenn ich eine Methode und das ist ein bisschen ähnlich wie eine 07:03.520 --> 07:06.780 Funktion in der Mathematik, ganz grob, deswegen gerne der Begriff, 07:06.980 --> 07:08.680 also dass der Buchstabe F dafür verwendet. 07:08.680 --> 07:13.160 Wenn ich eine Methode F aufrufe, dann kann ich verschiedene Parameter 07:13.160 --> 07:16.700 übergeben mit Komma getrennt und die einzelnen Parameter können zum 07:16.700 --> 07:19.540 Beispiel eine Variable wie X sein, aber können auch ganze Ausdrücke 07:19.540 --> 07:21.520 sein, also auch kompliziertere Berechnungen. 07:22.060 --> 07:25.620 Und ich kann Ausdrücke auch verwenden als Rückgabewerte von 07:25.620 --> 07:25.860 Funktionen. 07:26.280 --> 07:28.540 Da gibt es das Schlüsselwort return, das sehen wir dann auch beim 07:28.540 --> 07:31.300 nächsten Mal noch genauer und hinter diesem return kann auch ein 07:31.300 --> 07:32.060 Ausdruck stehen. 07:32.240 --> 07:36.980 Also ich könnte jetzt schreiben als Ergebnis einer Funktion return X, 07:36.980 --> 07:38.920 man soll den berechneten Wert von X zurückgeben. 07:39.340 --> 07:43.120 Ich könnte aber auch schreiben return X plus Y und dieses X plus Y 07:43.120 --> 07:44.280 wäre eben ein Ausdruck. 07:45.180 --> 07:47.640 Das jetzt erstmal für die Frage, wo können solche Ausdrücke 07:47.640 --> 07:47.980 auftauchen? 07:48.820 --> 07:51.240 Interessanter vielleicht die Frage, was ist überhaupt so ein Ausdruck 07:51.240 --> 07:52.120 oder wie sieht das aus? 07:52.200 --> 07:52.980 Was sind Beispiele? 07:53.620 --> 07:57.700 Hier in dieser Tabelle haben wir ein paar Beispiele für Ausdrücke. 07:58.100 --> 08:02.560 Wichtig ist noch zu sagen, der Punkt hier oben, ein Ausdruck hat immer 08:02.560 --> 08:03.460 einen Typ. 08:03.460 --> 08:07.900 Also wie gerade schon gesagt, die Ausdrücke sind ja oder werden dafür 08:07.900 --> 08:12.640 verwendet, um vorzunehmende Auswertungen zu beschreiben und diese 08:12.640 --> 08:14.400 Auswertungen haben immer auch ein Ergebnis. 08:14.680 --> 08:18.420 Also X plus Y ergibt irgendeinen, wenn das beides Integerwerte sind, 08:18.800 --> 08:22.400 irgendeinen Integerwert, den man zum Beispiel wieder als Variable Z 08:22.400 --> 08:23.120 ablegen könnte. 08:24.080 --> 08:28.440 Jeder Ausdruck hat also einen Typ und jeder Ausdruck liefert auch ein 08:28.440 --> 08:28.920 Ergebnis. 08:29.300 --> 08:31.360 Oder andersrum gesagt, jeder Ausdruck liefert ein Ergebnis. 08:31.360 --> 08:33.760 Zum Beispiel X plus Y ergibt ein Ergebnis. 08:34.740 --> 08:38.840 Und entsprechend der Typen, die in dem Ausdruck verwendet haben, hat 08:38.840 --> 08:41.160 auch der Ausdruck selber wieder einen Typ. 08:41.320 --> 08:45.360 Wenn ich also X plus Y rechne und X und Y sind beides Integerwerte, 08:45.740 --> 08:49.060 dann ist der Ausdruck X plus Y auch vom Typ Integer. 08:50.200 --> 08:53.000 Hatten wir bei den Operatoren ja auch schon ein bisschen besprochen. 08:54.740 --> 08:57.160 Beispiele für Ausdrücke sind also die folgenden. 08:57.680 --> 09:00.560 So eine Berechnung, wie ich es eben auch schon hatte, wenn ich 09:00.560 --> 09:04.700 schreibe Klammer auf 3,0, sage ich jetzt mal auf Deutsch, wobei sie 09:04.700 --> 09:09.500 natürlich den Punkt schreiben müssen, plus Y Klammer zu mal 4,0. 09:10.120 --> 09:13.740 Das ist so eine Auswertung, die vorgenommen werden soll. 09:14.480 --> 09:18.040 Und da das hier 3,0 und 4,0 sind auf jeden Fall schon mal Double 09:18.040 --> 09:21.500 -Werte, nehmen wir mal an, Y sei auch eine Variable vom Typ Double, 09:21.620 --> 09:25.620 dann hat dieser Ausdruck eben das Ergebnis hiervon auch den Typ 09:25.620 --> 09:26.080 Double. 09:26.080 --> 09:29.540 Wie ich beim letzten Mal erläutert hatte, ist es in Java ja so, anders 09:29.540 --> 09:33.440 als in anderen Programmiersprachen, wie zum Beispiel Python, dass von 09:33.440 --> 09:38.400 jedem Ausdruck der Typ eben schon zur Compile-Zeit festgestellt werden 09:38.400 --> 09:39.060 kann. 09:39.260 --> 09:42.500 Also es ist immer typsicher, es ist immer klar, was bei so einem 09:42.500 --> 09:45.400 Ausdruck herauskommt, weil eben für die Variable Y auch schon 09:45.400 --> 09:48.800 definiert sein muss, wo die Variable deklariert wird, von welchem Typ 09:48.800 --> 09:49.820 diese Variable ist. 09:50.760 --> 09:52.200 Das ist also so ein ganz typischer Ausdruck. 09:52.200 --> 09:57.240 So was wie hier, den New Operator ist auch ein Ausdruck. 09:57.320 --> 10:01.380 Wenn ich also schreibe New Vector2D mit zwei Werten, die ich für die X 10:01.380 --> 10:05.000 -Position und die Y-Position übergebe, dann ist dieses Ganze hier auch 10:05.000 --> 10:08.540 ein Ausdruck und zwar ein Ausdruck vom Typ Vector2D. 10:08.760 --> 10:11.920 Dieser New Operator liefert immer eine Objektreferenz auf das gerade 10:11.920 --> 10:15.820 erzeugte Objekt zurück und der ist eben vom Typ Vector2D. 10:17.000 --> 10:18.820 Hier noch ein drittes Beispiel für einen Ausdruck. 10:18.820 --> 10:21.940 X gleich gleich lese ich jetzt mal vor 2. 10:22.380 --> 10:26.260 Also einfach nur natürlich sprachlich ausgesprochen würde das heißen, 10:26.340 --> 10:30.480 ist X gleich 2, ist ein Ausdruck vom Typ Boolean. 10:30.660 --> 10:34.040 Also Wahrheitswert, hier kommt entweder True oder False heraus. 10:35.480 --> 10:36.540 Da noch eine Bemerkung am Rande. 10:36.660 --> 10:39.280 So ein Ausdruck vom Typ Boolean nennt man auch Bedingung, weil das 10:39.280 --> 10:42.460 dann eben wahr oder falsch sein kann oder zu wahr oder falsch 10:42.460 --> 10:45.100 ausgewertet werden kann, was da passiert. 10:45.780 --> 10:50.160 Genau, das sind erstmal prinzipiell Ausdrücke in Java. 10:52.100 --> 10:54.800 Hier sind noch ein paar mehr Beispiele und noch ein paar mehr 10:54.800 --> 10:57.140 Informationen dazu. 10:58.900 --> 11:01.880 Ausdrücke können, wir haben hier gerade eben schon ein paar Beispiele 11:01.880 --> 11:05.140 gesehen, wo verschiedene Elemente sozusagen drin sind. 11:05.220 --> 11:08.140 Hier das 3,0, das Y, die Klammern und so weiter. 11:08.800 --> 11:11.080 Also wenn wir da jetzt mal reinschauen, woraus besteht ein solcher 11:11.080 --> 11:11.580 Ausdruck? 11:11.580 --> 11:16.580 Es setzt sich zusammen aus Variablen oder Attributen oder Konstanten. 11:17.000 --> 11:18.820 X zum Beispiel, hier war ein Beispiel für eine Variable. 11:19.200 --> 11:21.200 4,0 war ein Beispiel für eine Konstante. 11:21.920 --> 11:25.500 In Ausdrücken können auch Methodenaufrufe vorkommen, die wiederum 11:25.500 --> 11:28.980 Ausdrücke bei den übergebenen Parametern haben können. 11:30.300 --> 11:34.220 Ein Ausdruck kann eben auch bestehen aus wiederum zwei Ausdrücken mit 11:34.220 --> 11:36.920 einem binären Operator kombiniert, wie zum Beispiel Plus. 11:36.920 --> 11:40.720 Also X plus Y wäre hier dieser Fall. 11:41.700 --> 11:44.900 X selber ist auch ein Ausdruck, weil eine Variable, ein Plus ist ein 11:44.900 --> 11:48.040 Operator und ein Y wäre dann ein zweiter Ausdruck. 11:48.420 --> 11:51.460 Hier soll eben mit dieser Schreibweise hier ein beliebiger binärer 11:51.460 --> 11:54.200 Operator, also ein Operator, der zwischen zwei Ausdrücken steht, 11:54.680 --> 11:55.200 gemeint sein. 11:56.420 --> 11:59.980 Ein Ausdruck kann auch ein unnäherer Operator gefolgt von einem 11:59.980 --> 12:01.400 weiteren Ausdruck sein. 12:02.020 --> 12:04.660 Also zum Beispiel Minus X könnte man schreiben. 12:05.540 --> 12:08.960 Ein Ausdruck kann eben sein New Operator gefolgt von einem 12:08.960 --> 12:13.700 Klassennamen und ein Ausdruck kann auch eine ganze Zuweisung sein. 12:13.900 --> 12:19.220 Also selbst so etwas wie X gleich zwei oder so was, oder X bekommt 12:19.220 --> 12:22.780 zugewiesen den Wert zwei, kann ich auch als Ausdruck an bestimmten 12:22.780 --> 12:24.760 Stellen oder in meinem Programmcode verwenden. 12:26.620 --> 12:29.020 Daraus setzen sich also Ausdrücke zusammen. 12:29.920 --> 12:32.480 Es gibt in Java noch ein paar spezielle Ausdrücke. 12:32.480 --> 12:36.560 Man kann das sogenannte Schlüsselwort InstanceOf benutzen und hier 12:36.560 --> 12:40.900 zwei Dinge einsetzen, nämlich eine Objektreferenz und einen 12:40.900 --> 12:45.240 Klassennamen und kann mit diesem Ausdruck dann prüfen, ob das Objekt, 12:45.320 --> 12:48.440 was mit dieser Objektreferenz bezeichnet ist, eine Instanz von der 12:48.440 --> 12:51.080 Klasse, die ich an die zweite Stelle schreibe, ist. 12:51.160 --> 12:55.860 Wie zum Beispiel ich kann schreiben P InstanceOf Vector2D. 12:56.260 --> 12:57.920 Das Ergebnis ist dann vom Typ Boolean. 12:58.080 --> 12:59.880 Also dieser Ausdruck ist vom Typ Boolean. 13:00.380 --> 13:04.600 Dann gibt es hier noch eine ganz nette Möglichkeit in Java mit diesem 13:04.600 --> 13:06.100 Fragezeichen -Doppelpunkt-Kombination. 13:06.540 --> 13:07.880 Da kann ich an drei Stellen was einfügen. 13:08.800 --> 13:12.540 Das ist ein sogenannter bedingter Ausdruck oder auch wenn, dann sonst. 13:12.940 --> 13:14.360 Ich kann zum Beispiel so was schreiben. 13:15.540 --> 13:17.200 Ist X gleich drei? 13:17.660 --> 13:19.820 Deswegen auch mit dem Fragezeichen hier ganz schön als Frage 13:19.820 --> 13:20.320 formuliert. 13:20.760 --> 13:21.880 Ist X gleich drei? 13:22.140 --> 13:26.960 Dann soll dieser Ausdruck den Wert fünf annehmen, sonst den Wert X 13:26.960 --> 13:27.540 plus zwei. 13:27.540 --> 13:30.980 Ich könnte also zum Beispiel eine dritte Variable oder eine zweite 13:30.980 --> 13:32.020 Variable Z einführen. 13:32.540 --> 13:35.060 Sagen Z gleich dieser Ausdruck hier. 13:35.600 --> 13:39.720 Und wenn X dann den Wert drei hat, dann ist das Ergebnis dieses 13:39.720 --> 13:40.660 Ausdrucks der Wert fünf. 13:40.800 --> 13:47.340 Und sonst ist das Ergebnis dieses Ausdrucks X plus zwei, was auch 13:47.340 --> 13:48.100 immer X gewesen ist. 13:49.600 --> 13:52.460 Und der dritte Ausdruck in Java ist die sogenannte Typumwandlung. 13:52.560 --> 13:54.260 Da kommen wir auch in der späteren Vorlesung nochmal zu. 13:54.260 --> 13:56.980 Aber zur Vollständigkeit hier. 13:57.380 --> 14:00.340 Ich kann also einen beliebigen Klassennamen in Klammern vor zum 14:00.340 --> 14:03.960 Beispiel eine Variable schreiben und damit Java anweisen, den Typ 14:03.960 --> 14:05.460 dieser Variable zu ändern. 14:06.100 --> 14:07.260 Also wenn ich jetzt hier... 14:07.260 --> 14:09.000 Aber da kommen wir später nochmal zu, wenn wir über Vererbung 14:09.000 --> 14:09.360 sprechen. 14:09.860 --> 14:12.900 Ja, das muss nicht unbedingt funktionieren, so was zu schreiben. 14:13.000 --> 14:15.180 Das kann man nur mit kompatiblen Klassen sozusagen machen. 14:15.600 --> 14:18.560 Aber damit kann ich eben den Typ einer Variable ändern. 14:19.600 --> 14:21.320 Gut, das wäre hier ein Beispiel. 14:21.660 --> 14:25.520 2,4 könnte ich eine Typumwandlung machen zu Integer und dann wird das 14:25.520 --> 14:29.040 0,4 weggestrichen und ich bekomme als Ergebnis nur eine 2, weil ein 14:29.040 --> 14:30.320 Integer ja ganz zahlig ist. 14:32.200 --> 14:34.180 Genau, hier ist nochmal eine Zuweisung. 14:35.140 --> 14:38.440 Die Zuweisung ist ja auch ein Ausdruck, wie eben gerade beschrieben. 14:38.940 --> 14:42.220 Und der Typ dieser Zuweisung ist vom selben Typ wie X. 14:42.440 --> 14:43.400 Einfach nur, dass man das weiß. 14:43.520 --> 14:45.400 Wie gesagt, jeder Ausdruck muss ja einen Typ haben. 14:47.280 --> 14:51.860 Gut, damit haben wir Ausdrücke jetzt gesehen, das heißt Vorschriften 14:51.860 --> 14:54.300 für den Rechner, wie er etwas auswerten soll. 14:55.080 --> 14:58.640 Das, woraus Programme eigentlich dann aufgebaut sind, sind sogenannte 14:58.640 --> 15:00.520 Anweisungen oder auch Statements. 15:01.100 --> 15:05.160 Also diese Anweisungen, Statements sind sozusagen die Einheiten der 15:05.160 --> 15:06.700 Ausführung eines Programms. 15:06.780 --> 15:09.460 Man kann sich das merken als sozusagen die Sätze einer 15:09.460 --> 15:13.140 Programmiersprache oder auch merken als es sind so die einzelnen 15:13.140 --> 15:16.400 Schritte im Ablauf der Berechnung, die gemacht werden müssen. 15:17.200 --> 15:21.940 Und so eine Anweisung veranlasst immer eine Zustands- oder fast immer 15:21.940 --> 15:24.160 eine Zustandsänderung meines Programms. 15:24.280 --> 15:26.840 Nicht unbedingt, oder je nachdem, wie fein Granulaumann guckt, bei 15:26.840 --> 15:28.220 einer Deklaration passiert nicht so viel. 15:28.340 --> 15:30.140 Da wird nur eine neue Variable dann verfügbar. 15:30.580 --> 15:33.780 Aber bei anderen Anweisungen kann auch noch mehr passieren. 15:33.880 --> 15:37.420 Insbesondere sich eben die Werte von Variablen ändern. 15:39.900 --> 15:42.700 Wie sehen Anweisungen in Java aus? 15:43.120 --> 15:46.120 Hier sind verschiedene Arten von Anweisungen, die Sie teilweise auch 15:46.120 --> 15:46.820 schon gesehen haben. 15:47.460 --> 15:50.820 Eine Anweisung ist zum Beispiel, eine lokale Variable zu deklarieren. 15:50.920 --> 15:51.600 Das kennen Sie schon. 15:51.960 --> 15:54.300 Können Sie hinschreiben, int x zum Beispiel, gefolgt von einem 15:54.300 --> 15:54.780 Semikolon. 15:55.280 --> 15:58.580 Und damit haben Sie eine neue lokale Variable deklariert, die Sie dann 15:58.580 --> 16:02.380 unter dieser Deklaration im weiteren Programmteil in dieser Methode 16:02.380 --> 16:03.060 verwenden können. 16:05.280 --> 16:08.560 Eine weitere Anweisung ist die sogenannte Blockanweisung. 16:08.680 --> 16:12.400 In Java kann man in geschweiften Klammern jeweils eine weitere Menge 16:12.400 --> 16:14.300 oder Sequenz von Anweisungen angeben. 16:14.460 --> 16:17.680 Und dieses in den geschweiften Klammern nennt man dann einen Block. 16:18.900 --> 16:22.140 Das haben Sie bei Methoden hinter der Main-Methode auch schon ein 16:22.140 --> 16:22.820 bisschen ähnlich gesehen. 16:22.940 --> 16:26.300 Aber das kann man auch beliebig irgendwo im Programmcode verwenden, 16:26.420 --> 16:26.820 diese Blöcke. 16:27.940 --> 16:31.820 Und eine weitere Anweisung ist die Return-Anweisung. 16:31.820 --> 16:34.000 Wir haben das eben schon gesehen, dass bei Return eben hier ein 16:34.000 --> 16:34.940 Ausdruck dahinter steht. 16:35.400 --> 16:38.780 Das Ganze, also Return und dieser Ausdruck gefolgt von Semikolon, ist 16:38.780 --> 16:40.640 dann eine sogenannte Return-Anweisung. 16:41.240 --> 16:43.320 Je nachdem, was man für eine Methode hat, kann man den Ausdruck 16:43.320 --> 16:45.520 dahinter auch sogar manchmal weglassen und einfach nur Return, 16:45.840 --> 16:49.160 Semikolon schreiben, um zu sagen, hier ist das Ende oder hier soll aus 16:49.160 --> 16:51.540 der Methode, in der ich gerade bin, herausgesprungen werden. 16:51.740 --> 16:53.340 Sehen wir uns genauer dann auch beim nächsten Mal. 16:55.400 --> 16:59.020 Eine weitere Art von Anweisungen in Java sind die sogenannten 16:59.020 --> 17:02.500 Expression -Statements, also Ausdrucksanweisungen. 17:02.600 --> 17:04.500 Da geht es ein bisschen durcheinander, die Ausdrücke und die 17:04.500 --> 17:04.980 Anweisungen. 17:05.180 --> 17:06.840 Also muss man ein bisschen darüber nachdenken. 17:07.900 --> 17:11.340 Das sind in Java Ausdrücke, was wir eben schon gesehen haben, die 17:11.340 --> 17:15.960 gleichzeitig auch für sich als Anweisungen verwendet werden können. 17:16.700 --> 17:19.180 Zum Beispiel der Increment-Decrement-Operator. 17:19.440 --> 17:22.640 Eigentlich I++ ist ja hier etwas, was jetzt auf der rechten Seite 17:22.640 --> 17:25.780 normal als Ausdruck verwendet wird im Rahmen einer anderen Anweisung. 17:26.160 --> 17:28.500 Ich kann das aber auch alleine einfach hinschreiben, gefolgt von 17:28.500 --> 17:30.800 Semikolon und dann ist es eine Anweisung. 17:32.800 --> 17:33.680 Ebenso Zuweisung. 17:34.060 --> 17:35.640 Auch eine Zuweisung ist ein Ausdruck. 17:35.840 --> 17:37.500 Ich kann das zum Beispiel so was hier hinschreiben. 17:38.240 --> 17:41.440 Aber ich kann eine Zuweisung auch alleine gefolgt von einem Semikolon 17:41.440 --> 17:44.580 hinschreiben und dann ist es eine Anweisung, steht für sich und der 17:44.580 --> 17:48.280 Computer bearbeitet sozusagen diesen Satz in der Programmiersprache 17:48.280 --> 17:49.020 einfach ab. 17:50.220 --> 17:53.040 Auch Methodenaufrufe sind eigentlich Ausdrücke, kann man aber auch 17:53.040 --> 17:54.280 alleine als Anweisung hinschreiben. 17:54.840 --> 17:57.880 Und ebenso auch der New-Operator, eigentlich ein Ausdruck, wie zum 17:57.880 --> 18:02.200 Beispiel hier P soll annehmen den neuen Wert von New Vector2D. 18:02.540 --> 18:03.900 So wäre es erstmal ein Ausdruck. 18:04.280 --> 18:08.120 Ich kann aber auch alleine schreiben New Vector2D und dann ist es eben 18:08.120 --> 18:11.060 ein sogenanntes Expression-Statement, ein Ausdruck, der auch als 18:11.060 --> 18:12.320 Anweisung stehen kann. 18:13.660 --> 18:18.020 Und als letzte Form der Anweisung, das, was wir uns heute genauer auch 18:18.020 --> 18:21.100 anschauen wollen, sind die sogenannten Control-Flow-Statements, also 18:21.100 --> 18:25.120 Kontrollflussanweisungen, wo es eben in dieser Vorlesung darum gehen 18:25.120 --> 18:25.360 soll. 18:25.820 --> 18:28.820 Bevor wir da aber genau weiter einsteigen in die Control-Flow 18:28.820 --> 18:33.560 -Statements nochmal ein kleiner Vergleich zwischen Ausdrücken und 18:33.560 --> 18:37.960 Anweisungen hier in dieser Tabelle, also Ausdrücke jetzt wieder blau, 18:38.100 --> 18:38.980 Anweisungen rot. 18:40.120 --> 18:44.760 Ein Ausdruck, wenn wir uns anschauen, die erste Zeile, hat immer einen 18:44.760 --> 18:45.080 Typ. 18:45.280 --> 18:48.340 Wie gesagt, ein Ausdruck hat immer ein Ergebnis und dieses Ergebnis 18:48.340 --> 18:50.800 hat einen Typ, also hat auch der Ausdruck einen Typ. 18:50.900 --> 18:54.580 Zum Beispiel, wenn die Variablen x und y Integer sind, hat der 18:54.580 --> 18:57.460 Ausdruck x plus y auch den Typ Integer. 18:58.380 --> 19:01.980 Eine Anweisung hat keinen Typ, da ist es eigentlich egal, das ist 19:01.980 --> 19:03.480 einfach ein Satz in der Programmiersprache. 19:04.540 --> 19:07.360 Der Zweck dieser beiden Dinge ist auch unterschiedlich, also der Zweck 19:07.360 --> 19:10.640 beim Ausdruck ist eben etwas zu berechnen, etwas auszuwerten, wie wir 19:10.640 --> 19:11.380 eben gesagt haben. 19:11.580 --> 19:15.960 Und die Anweisung ist eher zu sehen als, wie gesagt, Beschreibung 19:15.960 --> 19:17.580 eines Schritts im Programmablauf. 19:17.720 --> 19:20.520 Mach dies, dann mach das, dann mach das, wären so drei Anweisungen 19:20.520 --> 19:21.060 hintereinander. 19:21.060 --> 19:23.720 Passt auch ein bisschen zu dem Wort Anweisung, wenn Sie jetzt Ihren 19:23.720 --> 19:26.320 Kommilitonen anweisen, irgendwas zu tun, holen Stuhl und dann macht 19:26.320 --> 19:29.920 das Fenster zu, dann wären das eben zwei Anweisungen, die dann 19:29.920 --> 19:32.480 irgendwie den Zustand des Raumes, in dem Sie gerade sind, danach dann 19:32.480 --> 19:35.640 hoffentlich verändern, wenn er das tut, was Sie gesagt haben. 19:36.240 --> 19:38.360 Bei Kommilitonen ja dann vielleicht nicht so klar, beim Computer halt 19:38.360 --> 19:38.540 schon. 19:39.680 --> 19:41.160 Dann, was ist der Effekt? 19:41.720 --> 19:44.720 Ein Ausdruck, wie gesagt, liefert ein Ergebnis, also der Effekt davon 19:44.720 --> 19:48.500 ist, dieser Ausdruck liefert einen Wert und der Effekt einer Anweisung 19:48.500 --> 19:51.820 ist, die Anweisung ändert den Zustand meines Programms eben häufig 19:51.820 --> 19:54.500 dadurch, dass variablen Werte zum Beispiel anders werden. 19:55.500 --> 19:57.740 Oder auch einfach, dass ich im Programmablauf fortschreite. 19:58.700 --> 20:01.360 Und in der Syntax kann ich das Ganze unterscheiden, ein Ausdruck hat 20:01.360 --> 20:03.460 keinen Semikolon am Ende, das kann man jetzt mit den ganzen 20:03.460 --> 20:06.100 Anführungszeichen nicht so gut sehen, aber hier steht ohne Semikolon 20:06.100 --> 20:09.960 und bei der Anweisung, eine Anweisung ist eben immer gefolgt von einem 20:09.960 --> 20:10.480 Semikolon. 20:10.680 --> 20:13.720 Das ist eigentlich das Wichtigste, woran Sie die zwei unterscheiden 20:13.720 --> 20:16.300 können, weil wir eben gesehen haben, einige Ausdrücke kann man auch 20:16.300 --> 20:20.000 als Anweisung benutzen, aber der wichtige Unterschied, an dem man das 20:20.000 --> 20:23.940 im Programmcode unterscheiden kann, ist eben, dass eine Anweisung von 20:23.940 --> 20:27.840 einem Semikolon gefolgt werden oder gefolgt werden muss. 20:30.820 --> 20:35.280 Im Programmcode kommt oder sagen wir so, ein Programm besteht erstmal 20:35.280 --> 20:39.240 aus einer Menge von Anweisungen, sonst nichts und daher ist ein 20:39.240 --> 20:41.100 Ausdruck immer ein Teil einer Anweisung. 20:41.100 --> 20:43.460 Ich kann in meinem Programm nicht einen Ausdruck allein stehen haben, 20:43.560 --> 20:46.200 sondern ich muss ihn immer in einer Anweisung stehen haben, weil ein 20:46.200 --> 20:47.660 Programm eben aus Anweisungen besteht. 20:48.340 --> 20:52.020 Und der Rumpf einer Methode ist auch immer eine Folge von solchen 20:52.020 --> 20:52.580 Anweisungen. 20:54.680 --> 20:59.660 So, jetzt können Sie kurz überlegen oder sich nachprüfen, haben Sie 20:59.660 --> 21:01.180 das soweit mitgenommen? 21:03.460 --> 21:07.540 Die Frage an Sie, bei welchen dieser Java-Fragmente, also die sind 21:07.540 --> 21:11.420 unvollständig, es gibt also nicht die Deklaration der Variablen und so 21:11.420 --> 21:13.600 weiter, das haben wir jetzt hier alles mal weggelassen, aber bei 21:13.600 --> 21:16.420 welchen dieser Java-Fragmente oder wir könnten auch sagen, bei welchen 21:16.420 --> 21:20.180 dieser Java-Zeilen handelt es sich um gültige Anweisungen? 21:21.500 --> 21:25.160 Dazu für Sie jetzt eben die Möglichkeit, da zwei Minuten drüber 21:25.160 --> 21:25.380 nachzudenken. 21:25.960 --> 21:28.160 Sie können auch nach einer Minute, wenn Sie möchten, mit Ihren 21:28.160 --> 21:31.120 Nachbarn anfangen, sich auszutauschen darüber und dann sammeln wir 21:31.120 --> 21:33.640 dann gleich per Handzeichen, wer was meint. 21:35.020 --> 21:40.280 Gut, Sie hatten ein bisschen Gelegenheit, drüber nachzudenken und auch 21:40.280 --> 21:42.180 mit Ihren Nachbarn sich darüber auszutauschen. 21:42.180 --> 21:48.040 Also frage ich jetzt in die Runde, wer meint, dass das erste P, 21:48.500 --> 21:54.680 bekommt den neuen Wert New Vector 2D Punkt Shift 1,2, dass das eine 21:54.680 --> 21:56.200 gültige Anweisung ist? 22:00.530 --> 22:03.630 Das sind nicht so viele, das ist aber tatsächlich eine gültige 22:03.630 --> 22:04.470 Anweisung. 22:04.470 --> 22:10.590 Vielleicht waren Sie jetzt kurz noch verwirrt, sage ich mal, oder es 22:10.590 --> 22:12.910 ist auch okay, wenn Sie das jetzt noch nicht direkt erkennen konnten, 22:13.250 --> 22:16.870 weil dieses Punkt Shift hier hinter etwas ungewohnt noch ist. 22:16.990 --> 22:21.670 Das ist tatsächlich ein Methodenaufruf, aber hier das New Vector 2D 22:21.670 --> 22:23.450 ist ohnehin ein Ausdruck. 22:24.750 --> 22:28.030 Auf diesem Ergebnisobjekt kann ich wiederum die Methode Shift 22:28.030 --> 22:29.230 aufrufen. 22:29.230 --> 22:33.490 Wir würden jetzt mal für den Kontext dieses Beispiels davon ausgehen, 22:33.570 --> 22:36.030 dass Shift eine Methode ist, die den gleichen Rückgabewert hat, wie 22:36.030 --> 22:39.310 auch der Typ von P ist, also zum Beispiel wieder ein Vector 2D-Objekt 22:39.310 --> 22:39.850 zurückgibt. 22:40.090 --> 22:43.110 Und dann habe ich hier insgesamt halt eine Zuweisung, P soll bekommen 22:43.110 --> 22:45.370 diesen neuen Wert dieses großen Ausdrucks hier. 22:46.170 --> 22:48.830 Methodenaufruf, genau, hatten wir ja gerade auch erwähnt und damit ist 22:48.830 --> 22:50.210 das eine gültige Anweisung. 22:50.270 --> 22:52.990 Es ist eine Zuweisung, aber eine Zuweisung ist eben so ein genanntes 22:52.990 --> 22:55.990 Expression Statement, kann also auch als Anweisung mit Semikolon 22:55.990 --> 22:57.030 dahinter verwendet werden. 22:57.950 --> 23:02.890 Okay, wer denkt, dass das zweite hier, Int, also so ein Typecast, Foo, 23:03.090 --> 23:06.890 das ist ein Methodenaufruf mit dem Parameter X, eine gültige Anweisung 23:06.890 --> 23:07.230 ist? 23:09.730 --> 23:12.710 Das sind ein paar weniger und das ist in dem Sinne auch richtig, dass 23:12.710 --> 23:16.090 es keine gültige Anweisung ist. 23:16.470 --> 23:19.850 Der Typecast hier ist zwar ein Ausdruck, das haben wir ja schon 23:19.850 --> 23:22.470 gesehen, aber es ist eben kein Expression Statement, also den kann ich 23:22.470 --> 23:24.690 nicht alleine einfach so verwenden. 23:24.690 --> 23:26.970 Das macht auch irgendwie Sinn, weil wenn ich jetzt hier schon sage, 23:27.450 --> 23:31.130 ich habe eine Methode X, die ich aufrufe und für den Rückgabewert will 23:31.130 --> 23:34.410 ich den Typ umwandeln, wenn ich danach nichts mache mit diesem Typ, 23:34.470 --> 23:36.430 weil ich hier dann zum Beispiel keine Zuweisung und so weiter mache, 23:36.510 --> 23:38.350 dann hätte ich mir die Typumwandlung auch sparen können. 23:38.850 --> 23:41.490 Also deswegen können in Java die Typumwandlung nicht alleine stehen 23:41.490 --> 23:45.630 als Expression Statement, sondern das so zu schreiben wäre gültig als 23:45.630 --> 23:49.950 Ausdruck, aber mit Semikolon dahinter alleine als Anweisung nicht. 23:50.750 --> 23:51.890 Dann das dritte. 23:52.350 --> 23:56.610 X bekommt zugewiesen, Y bekommt zugewiesen, den Wert Z. 23:56.730 --> 23:57.670 So lese ich es jetzt mal vor. 23:57.750 --> 23:59.070 Ist das eine gültige Anweisung? 23:59.910 --> 24:00.370 Wer meint ja? 24:03.070 --> 24:06.850 Das sind schon wieder ein paar mehr, glaube ich, als eben und das ist 24:06.850 --> 24:08.470 auch richtig. 24:09.070 --> 24:12.270 Eine Zuweisung ist ja wieder auch ein Ausdruck, das hatten wir 24:12.270 --> 24:12.650 gesehen. 24:13.790 --> 24:17.850 Also was hier steht, Y, Zuweisungen sind ein bisschen speziell, weil 24:17.850 --> 24:19.450 man die immer von rechts nach links lesen muss. 24:19.570 --> 24:24.390 Also hier steht, X soll bekommen den neuen Wert von sozusagen Klammer 24:24.390 --> 24:28.510 auf, Y soll bekommen den neuen Wert von Z, Klammer zu, Klammer zu, so 24:28.510 --> 24:29.390 kann man sich das vorstellen. 24:31.130 --> 24:35.090 Das heißt, hier wird zunächst der Wert der Variablen jetzt auch in Y 24:35.090 --> 24:35.790 abgelegt. 24:36.210 --> 24:40.750 Dieser Ausdruck hier, Y, Zuweisung, den Wert von X, ist wiederum ein 24:40.750 --> 24:44.830 Ausdruck, auch Expression Statement und bei der Zuweisung kann eben 24:44.830 --> 24:46.870 auf der rechten Seite ein Ausdruck stehen, der Ausdruck ist vom 24:46.870 --> 24:50.130 gleichen Wert wie Y, wenn dann X auch einen passenden Typ hat, kann 24:50.130 --> 24:50.810 man das so hinschreiben. 24:53.270 --> 24:58.030 Und zum Letzten, wer meint, dass das vierte hier, Y++ in Klammern, 24:58.250 --> 25:00.030 eine gültige Anweisung ist? 25:03.460 --> 25:06.380 Das sind wieder, naja, ich würde jetzt mal sagen, optimistisch gesagt, 25:06.460 --> 25:08.620 ein bisschen weniger als eben, das ist tatsächlich keine gültige 25:08.620 --> 25:13.240 Anweisung, weil da jetzt die Spezialregel ist, dass das++ der 25:13.240 --> 25:17.180 Operator, man muss auch auf die Details achten, nur auf Variablen 25:17.180 --> 25:18.780 geht, also deswegen kompiliert das hier nicht. 25:19.540 --> 25:22.720 Man kann also nicht schreiben, irgendwas in Klammern, nicht irgendein 25:22.720 --> 25:27.660 Ausdruck gefolgt von++, weil dann für den Java-Interpreter nicht klar 25:27.660 --> 25:30.740 ist, was soll denn hier jetzt eigentlich im Wert erhöht werden? 25:30.740 --> 25:34.660 Hier könnte man sagen, ist irgendwie ja klar, dass es I sein soll, 25:35.120 --> 25:39.020 aber ein Ausdruck in Klammern im Allgemeinen könnte ja auch X++ sein 25:39.020 --> 25:42.000 und da dann hinter++ zu schreiben, hätte keine Bedeutung. 25:42.140 --> 25:45.320 Also hinter einen Ausdruck kann ich nicht nochmal den Inkrement 25:45.320 --> 25:46.580 -Operator anwenden. 25:47.600 --> 25:51.000 Also zusammenfassend, das erste und das dritte sind gültige 25:51.000 --> 25:54.400 Anweisungen, das zweite und das vierte nicht, aber zugegebenerweise, 25:54.460 --> 25:58.380 das waren jetzt auch ein bisschen tricky Fälle an der Stelle, sollen 25:58.380 --> 26:00.320 aber eben nochmal darauf hinweisen, dass man hier schon so ein 26:00.320 --> 26:03.900 bisschen aufs Detail achten muss, wenn eben bei Inkrement-Operator 26:03.900 --> 26:07.300 gesagt wird, der geht nur auf Variablen, dann ist das hier eben keine 26:07.300 --> 26:08.500 gültige Aussage. 26:08.500 --> 26:12.480 Das Schöne ist, wenn Sie mit sowas wie Eclipse arbeiten, zeigt Ihnen 26:12.480 --> 26:15.300 die Entwicklungsumgebung dann auch an, dass irgendwas nicht stimmt. 26:15.800 --> 26:18.440 Auch wenn Sie im Texteditor arbeiten und versuchen, etwas zu 26:18.440 --> 26:21.980 kompilieren, würden Sie dann entsprechend vom Compiler eine 26:21.980 --> 26:26.900 Fehlermeldung bekommen bei zweitens und viertens und können dann eben 26:26.900 --> 26:28.880 herausfinden, was an der Stelle falsch ist. 26:28.880 --> 26:32.560 Ein Tipp vielleicht an der Stelle, wenn Sie von dem Compiler, den Sie 26:32.560 --> 26:35.520 benutzen, eine Fehlermeldung bekommen und keine Ahnung haben, was das 26:35.520 --> 26:38.160 bedeutet, weil manchmal ist das ein bisschen kryptisch, dann versuchen 26:38.160 --> 26:41.140 Sie einfach, das bei Google einzugeben, diese Fehlermeldung, um dann 26:41.140 --> 26:42.580 herauszufinden, woran hat es wohl gelegen. 26:43.580 --> 26:46.440 Da finden Sie dann bei Stackoverflow oder sowas oftmals gute Bedeutung 26:46.440 --> 26:46.720 dafür. 26:48.500 --> 26:50.700 Wenn man sich auskennt, würde ich eigentlich sagen, eine 26:50.700 --> 26:53.080 Compilerfehlermeldung ist klar, was die meint, aber wenn man es eben 26:53.080 --> 26:55.340 nicht kennt, dann hilft es manchmal, ein bisschen danach zu suchen. 26:56.860 --> 27:01.440 Okay, so viel dann auch schon zu dem Teil zu Ausdrücken und 27:01.440 --> 27:02.140 Anweisungen. 27:06.110 --> 27:09.450 Ich warte kurz, bis alle den Schock dieser Fragen, was jetzt hier 27:09.450 --> 27:11.650 richtig ist und was falsch, verdaut haben und wieder ein bisschen Ruhe 27:11.650 --> 27:12.650 einkehrt im Hörsaal. 27:19.090 --> 27:19.510 Bitte. 27:19.510 --> 27:20.850 Genau, wir hatten ja darüber gesprochen. 27:22.110 --> 27:25.310 Mit Rücksicht auf Ihre Kommilitonen die Gespräche bitte auf nachher zu 27:25.310 --> 27:27.470 verschieben oder meinetwegen können Sie sich auch Nachrichten 27:27.470 --> 27:30.250 schreiben, aber bitte nicht zu viel reden, dann wird es zu unruhig im 27:30.250 --> 27:30.550 Hörsaal. 27:31.450 --> 27:32.830 Okay, kommen wir also zum nächsten Teil. 27:33.210 --> 27:34.770 Ausdrücke, Anweisungen haben wir uns jetzt angeschaut. 27:34.830 --> 27:39.270 Das nächste ist kurzer Einschub zu nochmal Eingaben, weil das etwas 27:39.270 --> 27:42.130 ist, was wir dann einfach gut in der Diskussion der 27:42.130 --> 27:44.910 Kontrollflussanweisung im Folgenden dann gebrauchen können. 27:48.650 --> 27:53.150 Hier der Hinweis oder die Vorschau quasi schon auf eine von Java 27:53.150 --> 27:58.370 mitgelieferte Klasse namens Scanner, die wir verwenden können, um 27:58.370 --> 28:01.850 Eingaben oder mit Eingaben von der Konsole umzugehen. 28:02.350 --> 28:05.710 Diese Klasse ist eben vorgefertigt von Java, heißt Scanner. 28:05.710 --> 28:09.350 Wenn ich die verwenden will, muss ich in der ersten Zeile meiner 28:09.350 --> 28:12.730 Klasse ein sogenanntes Import-Statement hineinschreiben. 28:12.850 --> 28:16.630 Das bedeutet, dass im folgenden mein Programmcode auch die Klasse 28:16.630 --> 28:19.930 namens Scanner, die von Java mitgeliefert wird, verwenden soll. 28:20.110 --> 28:22.690 Wenn ich das nicht mache, dann weiß der Compiler nicht, was ich hier 28:22.690 --> 28:23.370 mit Scanner meine. 28:23.850 --> 28:25.610 Aber hier habe ich sozusagen diese Referenz gesetzt. 28:26.210 --> 28:29.990 Ich kann dann ein solches Scanner-Objekt erzeugen mit dem New 28:29.990 --> 28:30.550 -Operator. 28:30.730 --> 28:34.090 Also ich kann sagen, ich will eine neue Variable, keinen geschriebenen 28:34.090 --> 28:38.730 Scanner vom Typ Scanner deklarieren und gleichzeitig initialisieren 28:38.730 --> 28:41.390 mit dem Wert New Scanner sozusagen. 28:41.690 --> 28:45.530 Also ich will ein neues Objekt vom Typ Scanner erzeugen und das dann 28:45.530 --> 28:47.410 in der Variable Scanner speichern. 28:47.490 --> 28:50.010 Das ist also in der Variable Scanner dann eine Objektreferenz auf das 28:50.010 --> 28:52.030 neu erzeugte Scanner-Objekt. 28:52.030 --> 28:56.190 Diesem Scanner-Objekt muss ich noch System.in als Parameter übergeben, 28:56.290 --> 28:59.270 damit dieses Scanner-Objekt eben weiß, dass es sozusagen von der 28:59.270 --> 29:00.330 Konsole lesen soll. 29:00.470 --> 29:02.590 Also dieses System.in sozusagen ist die Konsole. 29:03.970 --> 29:09.150 Und ich kann dann eine Zeile von der Konsole einlesen mit diesem hier 29:09.150 --> 29:10.790 Scanner.nextline. 29:11.330 --> 29:14.670 Und was dieses dann macht, wenn Sie dieses kleine Programm hier 29:14.670 --> 29:18.270 ausführen würden, das hier ist ja, wir nennen jetzt mal unsere Klasse 29:18.270 --> 29:19.090 Terminal Input. 29:19.470 --> 29:22.390 Sie hat eine Main-Methode, da erinnern Sie sich, die Main-Methode ist 29:22.390 --> 29:26.590 ja immer der Einstiegspunkt in unser Java-Programm, muss deswegen auch 29:26.590 --> 29:27.990 dieses Format hier haben. 29:27.990 --> 29:31.450 Dann steht in meiner Main-Methode jetzt drin, erst mal mach eine 29:31.450 --> 29:35.490 Ausgabe auf der Konsole, gib etwas ein, Doppelpunkt, dann erzeuge ich 29:35.490 --> 29:41.990 mir dieses Scanner-Objekt und rufe Scanner.nextline auf und weise das 29:41.990 --> 29:45.830 Ergebnis, was vom Typ String ist, einer Variable Input zu. 29:45.830 --> 29:49.230 Und was dann passiert, wenn ich jetzt erst mal bis hier hin ausführe, 29:49.390 --> 29:52.670 also ich kompiliere erst mal mein Programm, dann führe ich Java 29:52.670 --> 29:56.310 Terminal Input, mein Programm aus, dann würde das Programm erst mal, 29:56.350 --> 30:00.130 gib etwas ein, Doppelpunkt auf der Kommandozeile ausgeben und dann 30:00.130 --> 30:03.650 hier mit so einem blinkenden Cursor sozusagen warten darauf, dass Sie 30:03.650 --> 30:07.630 etwas auf der Konsole eingeben, also zum Beispiel 5 Enter eingeben. 30:07.630 --> 30:10.830 Und wenn das der Fall ist, dann liefert dieses Scanner-Nextline dem 30:10.830 --> 30:12.650 Programm diese 5 zum Beispiel zurück. 30:12.770 --> 30:17.070 Sie können das als erst mal Zeichenkette speichern und dann wiederum 30:17.070 --> 30:21.070 ausgeben System.out.println, du hast folgendes eingegeben und dann den 30:21.070 --> 30:21.730 Input. 30:21.850 --> 30:23.610 Ich glaube, das Beispiel haben wir jetzt auch nochmal, ich weiß nicht, 30:23.670 --> 30:25.050 ob mit 5, tatsächlich mit 5. 30:25.730 --> 30:28.510 Wenn man das jetzt also macht, erst mal bis hier ausführt, das 30:28.510 --> 30:32.530 Programm wartet dann auf Ihre Eingabe, Sie drücken 5 Enter, dann würde 30:32.530 --> 30:35.790 das Programm hier eben sagen, du hast folgendes eingegeben, 5 und 30:35.790 --> 30:38.750 dann, weil wir hier dann das Ende dieser Main-Methode erreichen, sich 30:38.750 --> 30:39.070 beenden. 30:39.350 --> 30:42.450 Also dann ist das Programm zu Ende gelaufen sozusagen. 30:46.190 --> 30:48.230 Das sind allgemeine Eingaben. 30:48.450 --> 30:51.010 Hier, wie gesagt, dieses Nextline liefert einfach eine Zeichenkette 30:51.010 --> 30:53.310 zurück und eine 5 kann auch in einer Zeichenkette stehen. 30:53.910 --> 30:57.550 Oftmals beim Programmieren wollen wir aber mit Zahlen arbeiten und da 30:57.550 --> 31:03.070 bietet diese Klasse auch gleich die Möglichkeit, auch speziell schon 31:03.070 --> 31:06.210 zu sagen, ich erwarte hier einen Zahlenwert, der eingelesen werden 31:06.210 --> 31:06.490 soll. 31:06.490 --> 31:09.210 Ich kann also auch wieder hier das gleiche machen, Main-Methode, 31:09.870 --> 31:13.430 System.out.print, gebe eine Zahl ein, dann neues Scanner-Objekt 31:13.430 --> 31:16.830 erzeugen und unter der Variable Scanner sozusagen ablegen und dann 31:16.830 --> 31:20.090 schreiben, hier ist jetzt der Unterschied zur vorherigen Folie, eine 31:20.090 --> 31:24.990 neue Variable vom Typ Integer namens myNumber, eine Zuweisung, Scanner 31:24.990 --> 31:25.990 .nextInt. 31:26.250 --> 31:29.750 Also diese Methode NextInt kann ich aufrufen, um einen Integer-Wert 31:29.750 --> 31:32.650 von der Konsole einzulesen. 31:32.650 --> 31:35.290 Dann kann ich wieder sagen, System.out.println, du hast folgendes 31:35.290 --> 31:38.370 eingegeben mit der Zahl dahinter und dann zum Beispiel damit auch 31:38.370 --> 31:41.650 weiterrechnen mit dieser Zahl, System.out.println, die darauf folgende 31:41.650 --> 31:44.670 Zahl ist meine Zahl plus 1. 31:44.790 --> 31:47.770 Also hier ein Ausdruck, der die Zahl um 1 erhöht. 31:48.270 --> 31:51.110 Wenn man das jetzt ausführen würde, kompilieren und dann ausführen, 31:51.230 --> 31:53.370 etwas eingibt, wie gesagt, das Programm bleibt dann hier erstmal 31:53.370 --> 31:57.610 stehen, man selber kann mit 8 Enter die 8 eingeben, dann kommt als 31:57.610 --> 32:00.550 Ausgabe dann, du hast folgendes eingegeben, eine 8, die darauf 32:00.550 --> 32:01.970 folgende Zahl ist eine 9. 32:02.410 --> 32:05.650 Das können Sie gerne mal von den Folien in ein Beispielprogramm 32:05.650 --> 32:08.430 kopieren und damit ein bisschen herumspielen und herumexperimentieren, 32:08.510 --> 32:09.550 was man damit machen könnte. 32:11.010 --> 32:14.350 Dieses ScannerNextInt, wie gesagt, liest einen intischer Wert ein. 32:15.570 --> 32:18.490 Es passiert hier keine Fehlerbehandlung, also wenn Sie jetzt das 32:18.490 --> 32:22.950 NextInt benutzen, da aber dann Hallo Welt reinschreiben, dann gibt es 32:22.950 --> 32:24.430 eine Fehlerbehandlung. 32:24.550 --> 32:27.790 Da kommen wir später dann zu, wie man das im Programm auch abfangen 32:27.790 --> 32:30.870 könnte, wenn wir die Vorlesung zum Thema Exceptions haben. 32:30.870 --> 32:33.630 Aber jetzt, wenn Sie damit herumprobieren, können Sie natürlich auch 32:33.630 --> 32:35.790 mal ausprobieren, was passiert, wenn Sie eine Hallo Welt eingeben 32:35.790 --> 32:37.950 anstatt einer Zahl bei diesem Beispiel hier. 32:38.170 --> 32:41.050 Aber wundern Sie sich dann nicht, wenn eben eine Fehlermeldung vom 32:41.050 --> 32:42.850 Programm dann zurückgegeben wird. 32:43.670 --> 32:49.870 Gut, und mit diesem kleinen Ausblick auf Eingaben können wir dann auch 32:49.870 --> 32:51.450 schon zum nächsten Thema übergehen. 32:51.570 --> 32:54.350 Das ist jetzt einfach nur diese kleine Einführung gewesen, damit wir 32:54.350 --> 32:57.510 jetzt im Folgenden, wenn wir Kontrollflussanweisungen besprechen, auch 32:57.510 --> 32:59.850 die Möglichkeit haben, mit unterschiedlichen Zahlen was machen zu 32:59.850 --> 33:00.030 können. 33:01.490 --> 33:05.030 Jetzt kommt sozusagen der Hauptteil der Vorlesung, nachdem wir über 33:05.030 --> 33:08.490 Ausdruck und Anweisung gesprochen haben und über Eingaben, schauen wir 33:08.490 --> 33:14.730 uns jetzt eine besonders wichtige Klasse von Anweisungen an, nämlich 33:14.730 --> 33:17.650 die Kontrollflussanweisung, wo ich eben erreichen kann, dass mein 33:17.650 --> 33:20.390 Programm sozusagen nicht immer nur genau das gleiche tut, vielleicht 33:20.390 --> 33:23.630 mit unterschiedlichen Werten rechnet, sondern mein Programm auch 33:23.630 --> 33:27.710 tatsächlich je nach Situation, je nach Eingaben der Benutzer ganz 33:27.710 --> 33:30.010 unterschiedliche Pfade sozusagen gehen kann. 33:30.030 --> 33:33.790 Und die Kontrollflussanweisungen, die wir uns anschauen werden, wie 33:33.790 --> 33:36.870 bei den Lernzielen auch schon aufgelistet, sind zum einen diese 33:36.870 --> 33:41.310 Verzweigungsanweisung mit If und Switch, zum anderen dann die 33:41.310 --> 33:46.810 verschiedenen Schleifen, While, Do While oder For und dann noch zwei 33:46.810 --> 33:50.590 Anweisungen, die dazu genutzt werden können, Schleifenausführungen zu 33:50.590 --> 33:51.330 modifizieren. 33:51.630 --> 33:53.890 Aber da kommen wir dann gleich dazu, wenn wir wissen, was eine 33:53.890 --> 33:54.330 Schleife ist. 33:55.550 --> 33:59.350 Fangen wir aber zunächst mit dem Einfachsten dieser sozusagen drei 33:59.350 --> 34:03.930 Gruppen von Anweisungen an, nämlich dem If oder der sogenannten 34:03.930 --> 34:05.090 Fallunterscheidung. 34:05.190 --> 34:08.610 Das ist in Java, auch in den meisten Programmiersprachen, aber in Java 34:08.610 --> 34:11.450 eben ganz schön, dass hier das Schlüsselwort If benutzt wird und wir 34:11.450 --> 34:14.670 das quasi auf Englisch auch so ein bisschen lesen können, was das 34:14.670 --> 34:15.110 bedeutet. 34:16.030 --> 34:19.250 Also If-Anweisung wird verwendet zur Fallunterscheidung, das Wenn-Dann 34:19.250 --> 34:24.070 -Prinzip und das ist eben ganz fundamental in der Programmierung, dass 34:24.070 --> 34:28.290 ich zum Beispiel Eingaben des Benutzers auswerten kann und zum 34:28.290 --> 34:31.270 Beispiel, wenn die Zahl negativ ist, das eine machen kann und wenn die 34:31.270 --> 34:33.050 Zahl positiv ist, das andere machen kann. 34:33.050 --> 34:36.250 Zum Beispiel sowas wie eine Tabellenkalkulation, wenn die Zahl negativ 34:36.250 --> 34:38.730 ist, soll sie in rot angezeigt werden, wenn sie positiv ist, dann in 34:38.730 --> 34:39.050 schwarz. 34:39.450 --> 34:41.910 Für sowas brauche ich dann eine sogenannte Fallunterscheidung. 34:42.870 --> 34:46.570 In Java ist es wie gesagt das If, die If-Anweisung, If-Statement, 34:47.050 --> 34:49.530 Realisierung dieser Fallunterscheidung in Java. 34:49.630 --> 34:50.510 Wie sieht das aus? 34:51.430 --> 34:55.290 Hier zwei Varianten, so die grundlegende Variante ist die hier 34:55.290 --> 34:55.930 gezeigte. 34:55.930 --> 34:59.350 Ich habe das Schlüsselwort If, wenn Sie sowas wie Eclipse benutzen, 34:59.410 --> 35:02.350 wird es Ihnen dann auch farbig dargestellt, dass es eben ein sozusagen 35:02.350 --> 35:04.030 festes Wort in der Java-Sprache ist. 35:04.950 --> 35:08.290 Dahinter in Klammern eine Bedingung und Sie wissen jetzt schon, eine 35:08.290 --> 35:11.650 Bedingung ist ein Ausdruck vom Typ Boolean, also zum Beispiel sowas 35:11.650 --> 35:13.370 wie x gleich gleich y. 35:15.190 --> 35:21.010 In Klammern diese Bedingung gefolgt von einer geschweiften Klammer, 35:21.130 --> 35:24.930 die kann man auch weglassen, aber idealerweise machen wir es jetzt mal 35:24.930 --> 35:26.710 einfach gefolgt von einer geschweiften Klammer. 35:26.710 --> 35:31.630 Hier geschweifte Klammer auf, geschweifte Klammer zu und zwischen 35:31.630 --> 35:33.770 diesen beiden geschweiften Klammern können Sie jetzt wieder eine Menge 35:33.770 --> 35:34.990 von Anweisungen schreiben. 35:35.130 --> 35:37.690 Es kann eine sein oder es können eben auch mehrere sein. 35:37.770 --> 35:40.650 Das sind die Anweisungen, die ausgeführt werden sollen, wenn diese 35:40.650 --> 35:42.410 Bedingung zu wahr auswertet. 35:42.610 --> 35:46.450 Also man liest es so, wenn die Bedingung gilt, dann führe diese 35:46.450 --> 35:49.290 Anweisung aus, die innerhalb der geschweiften Klammern stehen. 35:51.010 --> 35:53.670 Das ist sozusagen die einfache Fallunterscheidung oder einfach nur 35:53.670 --> 35:56.210 Überprüfung, ob eine Bedingung gilt und dann Ausführen von 35:56.210 --> 35:56.470 Anweisungen. 35:57.290 --> 35:59.870 Es gibt in Java und in den meisten anderen Programmiersprachen auch 35:59.870 --> 36:04.450 noch diese If-Else-Kombination, dass man also sagt, wenn eine 36:04.450 --> 36:07.530 bestimmte Bedingung gilt, dann führe diese Anweisung aus. 36:07.530 --> 36:12.090 Wenn nicht sozusagen, also sonst, führe diese anderen Anweisungen aus. 36:12.290 --> 36:16.050 Also dieses ist eine Verzweigung, was sowohl im Fall, dass die 36:16.050 --> 36:19.230 Bedingung gilt, als auch im Fall, dass die Bedingung nicht gilt, 36:19.570 --> 36:21.110 jeweils Anweisungen ausführt. 36:21.410 --> 36:24.510 Anweisung 1, wenn die Bedingung gilt und hier die Anweisung 2, wenn 36:24.510 --> 36:25.510 die Bedingung nicht gilt. 36:26.730 --> 36:31.030 Hier rechts sehen wir ein Beispiel, was jetzt gleich schon unsere 36:31.030 --> 36:32.990 Scanner -Klasse benutzt. 36:33.110 --> 36:35.230 Das ist jetzt auch wieder nur ein Ausschnitt aus einem Programm, weil 36:35.230 --> 36:38.230 wir jetzt hier diese Scanner-Variable nicht initialisiert haben. 36:38.330 --> 36:39.910 Das steht sozusagen obendrüber. 36:40.630 --> 36:46.150 Aber dieser Ausschnitt initialisiert erstmal zwei Variablen A und B, 36:46.290 --> 36:49.290 beide vom Typ Int, mit Werten, die wir beispielsweise von der 36:49.290 --> 36:51.530 Kommandozeile einlesen, wie wir es gerade gesehen haben. 36:52.550 --> 36:56.750 Initialisiert dann auch ein weitere Integer-Variable Max mit dem Wert 36:56.750 --> 36:57.090 0. 36:57.770 --> 37:00.390 All das 3 hier mit Semikolon gefolgt sind jeweils Anweisungen. 37:00.990 --> 37:05.770 Und dann haben wir die Verzweigung, das If, was eben abfragt, oder 37:05.770 --> 37:11.410 falls, ich lese es jetzt erstmal auf Deutsch sozusagen vor, falls A 37:11.410 --> 37:18.710 größer oder gleich B ist, dann setze Max auf den Wert von A, sonst 37:18.710 --> 37:20.550 setze Max auf den Wert von B. 37:21.430 --> 37:24.350 Also das heißt, kann man sich vorstellen, was dieses Programm hier 37:24.350 --> 37:24.770 machen soll. 37:24.830 --> 37:28.710 Es soll eben bestimmen, welcher Wert A oder B größer ist und die 37:28.710 --> 37:31.970 Variable Max soll das Maximum der beiden Werte sozusagen am Ende 37:31.970 --> 37:34.070 enthalten. 37:35.570 --> 37:39.210 Ich könnte jetzt nochmal kurz zurück in meine Folien springen, einfach 37:39.210 --> 37:41.550 nur der Vollständigkeit halber, weil ich jetzt gerade gesehen habe, 37:42.350 --> 37:45.470 dass hier der Zeilenumbruch nicht so schön ist, aber das ist schnell 37:45.470 --> 37:45.970 korrigiert. 37:47.030 --> 37:48.230 Einfach der Konsistenz halber. 37:49.130 --> 37:49.690 So. 37:52.570 --> 37:53.130 So. 37:54.110 --> 37:57.770 Genau, was ich jetzt gerade geändert habe, dass wir es hier ein 37:57.770 --> 38:01.870 bisschen einheitlich haben, dass Else direkt hinter die schließende 38:01.870 --> 38:06.010 geschweifte Klammer das ersten Teil des Ifs schreiben und dann kann 38:06.010 --> 38:08.250 man eben nach dem Schlüsselwort Else eine weitere geschweifte Klammer 38:08.250 --> 38:11.370 aufmachen und da die Anweisungen hineinschreiben, die eben im 38:11.370 --> 38:13.950 Sonstfall ausgeführt werden sollen. 38:15.110 --> 38:20.390 Gut, das ist erstmal, wie die If-Anweisung in Java aussieht. 38:20.930 --> 38:23.950 Wir können das Ganze uns auch nochmal als sogenannten 38:23.950 --> 38:27.550 Kontrollflussdiagramm, als sogenanntes Kontrollflussdiagramm 38:27.550 --> 38:30.590 veranschaulichen, was hier eigentlich in der Auswertung von so einer 38:30.590 --> 38:32.330 If -Anweisung passiert. 38:32.330 --> 38:34.970 Wir nehmen hier jetzt wieder einen Ausschnitt aus dem Beispiel, was 38:34.970 --> 38:40.050 wir eben haben, also Beispielanweisung If A größer gleich B, dann soll 38:40.050 --> 38:43.770 Max auf den Wert von A gesetzt werden, sonst soll Max auf den Wert von 38:43.770 --> 38:44.690 B gesetzt werden. 38:44.690 --> 38:48.690 Wir nehmen jetzt mal an, dass für das beispielhafte Durchgehen dieser 38:48.690 --> 38:52.610 Anweisung A den Wert 3 hat und B den Wert 2. 38:53.130 --> 38:55.750 Dann passiert bei der Ausforderung des Programms das folgende. 38:56.530 --> 39:00.130 Bei so einem Kontrollflussdiagramm habe ich immer einen Startknoten, 39:00.230 --> 39:01.310 kann dann durchgehen. 39:01.310 --> 39:09.170 Das erste ist diese Fallunterscheidung hier als so gekipptes Rechteck, 39:09.170 --> 39:11.450 Drachenform dargestellt. 39:11.910 --> 39:16.830 Die Auswertung ist A größer gleich B, also wird dieser Ausdruck zu 39:16.830 --> 39:19.830 wahr ausgewertet, dann nimmt man diesen Pfeil hier ausgehend aus 39:19.830 --> 39:23.610 diesem Knoten oder zu falsch ausgewertet hier auf der anderen Seite. 39:23.610 --> 39:30.370 In unserem Beispiel hier mit dieser Variablenbelegung würde dieser 39:30.370 --> 39:33.970 Ausdruck ausgewertet werden zu True. 39:34.870 --> 39:38.670 Das heißt, ich gehe dann in diesen Teil der Schleife hinein, setze Max 39:38.670 --> 39:42.130 auf den Wert von A und beende dann auch schon dieses kleine 39:42.130 --> 39:44.030 Programmfragment, was wir hier gesehen haben. 39:44.030 --> 39:47.630 Wenn wir das Ganze jetzt für eine andere Variablenbelegung ausführen 39:47.630 --> 39:50.690 würden, also hier jetzt vertauscht, B hat jetzt den Wert 3 und A den 39:50.690 --> 39:53.610 Wert 2, dann würde man wie folgt durchlaufen, wieder am Start 39:53.610 --> 39:56.570 anfangen, die Auswertung machen ist A größer gleich B. 39:56.570 --> 40:00.770 würde in dem Fall jetzt auf das Ergebnis oder die Auswertung false 40:00.770 --> 40:05.030 kommen, weil B eben mit 3 größer ist als A 2 und würde dann in den 40:05.030 --> 40:09.050 anderen Zweig hineinlaufen und Max bekommt den Wert von B zugewiesen, 40:09.370 --> 40:12.310 in diesem Falle dann eben 3 und danach endet dieser kleine 40:12.310 --> 40:14.470 Codeschnipsel, den wir hier dargestellt haben. 40:14.470 --> 40:18.650 Also so kann man für eine Menge von Anweisungen sich eben auch immer 40:18.650 --> 40:22.050 überlegen, wie sieht denn dieser sogenannte Kontrollflussgraf aus, was 40:22.050 --> 40:25.730 sind sozusagen die verschiedenen Pfade der Berechnung durch das 40:25.730 --> 40:27.250 Programm, die durchlaufen werden können. 40:30.930 --> 40:35.930 Gut, das zum einfachen Fall, hier ein etwas längerer Fall, eigentlich 40:35.930 --> 40:39.250 auch nicht viel komplizierter, aber man kann diese IF-Anweisungen auch 40:39.250 --> 40:39.990 noch schachteln. 40:40.410 --> 40:42.850 Das, was wir gerade gesehen haben, war ja, ich kann eine Bedingung 40:42.850 --> 40:46.630 testen und dann eine Anweisung machen, ich kann mit IF-ELTS sagen, 40:46.910 --> 40:52.150 wenn dann die erste Anweisung, sonst die zweite Anweisung, ich kann 40:52.150 --> 40:55.730 aber auch mehr als nur diese zwei Fälle unterscheiden und dafür 40:55.730 --> 40:58.150 verwendet man sogenannte geschachtelte IF-Anweisungen. 41:00.650 --> 41:04.690 Der Geräuschpegel scheint mir ein bisschen vielleicht störend hoch zu 41:04.690 --> 41:07.010 sein für die anderen, danke schön, jetzt ist besser. 41:07.950 --> 41:13.930 Geschachtelte IF-Anweisungen, ich kann also auch mehrere Fälle 41:13.930 --> 41:14.870 unterscheiden. 41:16.670 --> 41:21.910 Das kann ich machen, indem ich zum Beispiel hier mehrere Fälle 41:21.910 --> 41:22.370 unterscheide. 41:22.450 --> 41:25.230 Wir nehmen hier jetzt mal an, wir haben eine Integer-Variable Points, 41:25.350 --> 41:28.790 die aber anfangs den Wert 50 hat, eine Integer-Variable Grade auf 41:28.790 --> 41:31.290 englischen Note, die den Wert 0 hat und ich möchte jetzt mit diesem 41:31.290 --> 41:35.890 Programm für unterschiedliche Punkte, die man zum Beispiel in der 41:35.890 --> 41:38.250 Klausur oder so erreicht hat, dann die Note festsetzen. 41:38.250 --> 41:40.950 Und da habe ich eben nicht nur zwei Fälle, true und false, sondern ich 41:40.950 --> 41:41.990 habe eben mehrere Möglichkeiten. 41:42.230 --> 41:46.430 Ich will zum Beispiel ausdrücken, wenn man mehr als 87 Punkte erreicht 41:46.430 --> 41:50.570 hat, dann soll man eine 1 bekommen, mehr als 75 Punkte eine 2 und so 41:50.570 --> 41:50.830 weiter. 41:50.830 --> 41:53.770 Und das kann ich in Java hinschreiben, indem ich erstmal eine IF 41:53.770 --> 41:57.430 -Anweisung mache, IF Points größer gleich 87. 41:57.890 --> 42:02.230 Wenn diese Bedingung gilt, dann gehe ich hier in die Anweisungen, in 42:02.230 --> 42:05.630 den ersten sozusagen geschweiften Klammern und setze Grade, also die 42:05.630 --> 42:07.830 Ergebnis, die Note auf 1. 42:08.430 --> 42:11.170 Falls das nicht der Fall ist, also wenn ich weniger als 87 Punkte 42:11.170 --> 42:13.510 erreicht habe, dann gehe ich in den Else-Zweig. 42:14.090 --> 42:16.310 Eben hatten wir gesehen, dass der Else-Zweig direkt auch mit der 42:16.310 --> 42:18.770 geschweiften Klammer losgeht, aber hier kommt jetzt eben dieses 42:18.770 --> 42:19.770 Verschachteln ins Spiel. 42:20.230 --> 42:23.010 Ich kann direkt hinter das Else auch gleich wieder ein IF schreiben 42:23.010 --> 42:24.710 und die nächste Überprüfung machen. 42:24.710 --> 42:28.310 Also jetzt komme ich hier durch, sage, wenn die Punkte größer als 87 42:28.310 --> 42:32.490 sind, also wenn ja, dann mach dies, wenn nicht, dann prüfe weiter, 42:32.610 --> 42:36.230 wenn die Punkte zumindest größer als 75 sind, dann soll die Note 2 42:36.230 --> 42:40.590 sein, wenn das auch nicht, dann prüfe weiter, wenn die Punktzahl 42:40.590 --> 42:44.270 größer gleich 63 sein soll, dann soll die Note 3 sein, wenn nicht, 42:44.530 --> 42:45.210 dann prüfe weiter. 42:45.810 --> 42:51.950 Wenn die Punktzahl größer gleich 51 ist, soll die Note 4 sein, wenn 42:51.950 --> 42:55.890 das auch nicht der Fall ist, also ein Else jetzt ohne IF, dann ist die 42:55.890 --> 42:56.510 Note eine 5. 42:56.990 --> 42:59.810 Das ist jetzt Universitätssystem, 6 gibt es gar nicht, sondern 5 ist 42:59.810 --> 43:00.530 einfach durchgefallen. 43:01.190 --> 43:07.210 Und dann kann man am Ende ausgeben, die berechnete Note für die 43:07.210 --> 43:09.710 angegebene Punktzahl hier jetzt 50. 43:10.910 --> 43:14.210 In diesem Beispiel für 50 würde man hier eben am Ende landen, 5 zu 43:14.210 --> 43:17.050 weisen und eine 5 ausgeben, für unterschiedliche Punktzahlen dann eben 43:17.050 --> 43:18.050 unterschiedliche Dinge. 43:18.690 --> 43:21.770 Wenn man solche Verschachtelungen macht und das braucht man eben, wenn 43:21.770 --> 43:25.410 man sozusagen mehr als zwei Fälle unterscheiden will, sollte man nach 43:25.410 --> 43:28.350 Möglichkeit die am häufigsten auftretenden Fälle zuerst behandeln, 43:28.430 --> 43:30.290 dann wird das Programm einfach ein bisschen schneller und muss nicht 43:30.290 --> 43:31.990 so viel, also in den häufigen Fällen schneller. 43:31.990 --> 43:36.370 Und man kann hierbei noch bedenken oder sollte bedenken, dass wenn man 43:36.370 --> 43:40.710 es so aufschreitet, in jedem sogenannten Else-Zweig die Negation aller 43:40.710 --> 43:42.430 vorangegangenen Bedingungen gilt. 43:42.850 --> 43:46.470 Also wenn ich hier das hier gerade auswerte, dann weiß ich schon, dass 43:46.470 --> 43:49.030 Points nicht größer gleich 87 sein kann. 43:49.030 --> 43:52.210 Wenn das der Fall gewesen ist, wäre ich ja schon hier in diesen Zweig 43:52.210 --> 43:56.170 reingegangen und dann hätte ich hier nach quasi direkt das System Out 43:56.170 --> 43:57.390 Print Line ausgeführt. 43:57.490 --> 43:59.730 Also diesen Else-Teil hätte ich dann gar nicht erst ausgeführt. 44:00.390 --> 44:03.550 Man muss also hier auch auf die Reihenfolge der Bedingungen und dieser 44:03.550 --> 44:04.710 Verschachtelung achten. 44:05.350 --> 44:07.810 Wir schauen uns das nochmal im Kontrollfluss-Diagramm an. 44:08.910 --> 44:11.210 Genau den Code, den wir gerade gesehen haben. 44:11.910 --> 44:18.270 Man startet hier oben, wertet erst aus, sind es mehr als 87 Punkte. 44:18.410 --> 44:21.950 Wenn ja, ist die Note 1 und ich gehe zur Ausgabe. 44:22.530 --> 44:25.230 Wenn nein, ist es mehr als 75 Punkte. 44:25.490 --> 44:28.510 Wenn das wiederum ja ist, ist die Note 2 und ich gehe zur Ausgabe. 44:28.510 --> 44:31.330 Wenn das auch nicht der Fall ist, gehe ich weiter zur nächsten 44:31.330 --> 44:34.050 Auswertung und hier eventuell zur nächsten Auswertung und komme dann 44:34.050 --> 44:37.010 eben so auf diese verschiedenen Anweisungen. 44:37.550 --> 44:41.910 Dabei beachten, es wird pro Programmdurchlauf eben immer nur einer 44:41.910 --> 44:42.850 dieser Pfade genommen. 44:43.050 --> 44:47.630 Also es wird entweder die Note 1 gesetzt für die Variable oder 2 oder 44:47.630 --> 44:50.910 3 oder 4 oder 5, aber immer nur eins davon, weil die eben in diesen 44:50.910 --> 44:54.510 unterschiedlichen Zweigen des geschachtelten If Statements standen. 44:54.510 --> 44:58.030 Und am Ende wird dann eben diese Note ausgegeben und der 44:58.030 --> 45:01.050 Programmschnipsel ist zum Ende gekommen. 45:02.950 --> 45:07.970 Gut, das können Sie jetzt auch nochmal probieren, also mit If zu 45:07.970 --> 45:08.490 arbeiten. 45:09.110 --> 45:12.530 Die Frage an Sie und am besten machen Sie das auf einem Stück Papier 45:12.530 --> 45:14.810 oder wenn Sie einen Rechner haben, vielleicht auch einen Texteditor, 45:14.930 --> 45:17.730 weil im Kopf ist vielleicht ein bisschen schwierig, also finde ich 45:17.730 --> 45:17.990 zumindest. 45:17.990 --> 45:23.010 Wie gesagt, auf Papier oder auf dem Rechner schreiben Sie bitte ein 45:23.010 --> 45:29.330 Programm, das für zwei Integer-Eingaben A und B ausgibt, ob A größer 45:29.330 --> 45:32.250 oder kleiner oder gleich B ist. 45:33.890 --> 45:36.650 Das, ja, drei Minuten braucht man da bestimmt dafür, gebe ich Ihnen 45:36.650 --> 45:37.610 also drei Minuten Zeit. 45:37.990 --> 45:41.050 Versuchen Sie es erstmal für sich, aber wenn Sie dann soweit sind oder 45:41.050 --> 45:42.990 wenn Sie auch nicht weiterkommen, können Sie auch das mit Ihrem 45:42.990 --> 45:46.570 Nachbarn, wenn Sie wollen, gerne besprechen und dann zeige ich mal 45:46.570 --> 45:47.090 meine Lösung. 45:48.470 --> 45:50.310 Achso, ein kleiner Hinweis vielleicht noch. 45:50.730 --> 45:54.670 Die Syntax ist jetzt an der Stelle nicht ganz so wichtig, also das 45:54.670 --> 45:57.670 heißt, wie Sie es genau hinschreiben, ob Sie jetzt an alle Semikolons 45:57.670 --> 46:01.170 denken oder nicht, sei jetzt mal für hier in der Vorlesung erstmal 46:01.170 --> 46:01.850 zweitrangig. 46:01.930 --> 46:03.710 Versuchen Sie erstmal zu überlegen, ob Sie das mit der 46:03.710 --> 46:07.430 Fallunterscheidung verstanden haben und quasi die richtigen Ifs an der 46:07.430 --> 46:08.730 richtigen Stelle verwenden würden. 46:08.730 --> 46:13.090 Für die Präsenzübung später wird es auch einigermaßen wichtig sein, 46:13.210 --> 46:16.390 auch die Syntax zu beherrschen, aber das können Sie bis dahin ja noch 46:16.390 --> 46:16.970 einüben. 46:17.970 --> 46:21.330 Aber überlegen Sie erstmal, wie es quasi aufgebaut sein soll, bevor 46:21.330 --> 46:24.090 Sie sich dann an dem, wo jetzt genau die Semikolons hin sollen, 46:24.270 --> 46:25.190 aufhalten. 46:26.130 --> 46:27.970 So, das waren auch schon drei Minuten. 46:29.710 --> 46:32.130 Ich würde jetzt mal, und ich hoffe, Sie können meine Handschrift 46:32.130 --> 46:36.450 lesen, die Lösung erstmal Schritt für Schritt aufbauen, bevor ich 46:36.450 --> 46:40.590 Ihnen dann die Musterlösung sozusagen gleich einblende. 46:40.690 --> 46:42.950 Aber weil die schon ein bisschen länger ist, ist, glaube ich, 46:42.970 --> 46:46.170 hilfreicher, jetzt Schritt für Schritt vorzugehen, was wir hier machen 46:46.170 --> 46:46.550 müssen. 46:46.550 --> 46:49.690 Es geht ja um If-Statements, also haben Sie sich wahrscheinlich 46:49.690 --> 46:51.390 gedacht, dass Sie irgendwie ein If benutzen müssten. 46:52.130 --> 46:54.890 Und wir wollen hier eben drei verschiedene Fälle unterscheiden, 46:54.990 --> 46:59.950 nämlich ob A größer ist als B oder ob A kleiner ist als B oder ob A 46:59.950 --> 47:01.030 gleich ist als B. 47:01.110 --> 47:04.290 Und da kann man erstmal anfangen und quasi den ersten Fall abprüfen 47:04.290 --> 47:06.730 und ich fange jetzt in der Mitte des Programms an und ergänze das dann 47:06.730 --> 47:08.030 gleich vorne herum. 47:08.510 --> 47:09.810 Ups, jetzt habe ich es schon eingeblendet. 47:10.590 --> 47:12.310 So soll es eigentlich sein, Stift. 47:12.970 --> 47:16.370 Also ich kann sagen... oder auch nicht, weil ich hier am Rand 47:16.370 --> 47:16.730 schreibe. 47:16.990 --> 47:17.490 Oh ja, schade. 47:17.830 --> 47:18.730 Gut, dann blende ich es doch ein. 47:19.130 --> 47:19.870 Oder ich sage es erstmal. 47:20.730 --> 47:22.990 Ich will eben diese drei Fallunterscheidungen machen, das heißt, ich 47:22.990 --> 47:28.510 kann erstmal ein If schreiben, If A größer B, dann gebe aus, A ist 47:28.510 --> 47:29.210 größer als B. 47:29.210 --> 47:33.930 Wenn das nicht der Fall ist, also sonst, else, prüfe ich eins der 47:33.930 --> 47:36.930 anderen beiden Dinge, dann könnte ich zum Beispiel prüfen, If A 47:36.930 --> 47:38.130 kleiner als B. 47:38.930 --> 47:42.230 Und wenn das der Fall ist, könnte ich ausgeben, A ist kleiner als B. 47:43.150 --> 47:47.750 Oder als drittes, also wenn das auch nicht der Fall ist, else kann ich 47:47.750 --> 47:50.130 A ist gleich B ausgeben. 47:50.130 --> 47:52.990 Das sieht dann so aus, hier noch mit ein bisschen vorbereitenden 47:52.990 --> 47:55.850 Dingen, aber das... wo ist jetzt meine Maus? 47:55.930 --> 47:56.830 Soll jetzt nicht so wichtig sein. 47:56.890 --> 47:58.770 Hier ist eigentlich das Wichtigste. 47:59.250 --> 48:03.730 Wenn A größer B ist, dann gebe ich aus mit System.out.println, A ist 48:03.730 --> 48:04.290 größer als B. 48:04.910 --> 48:07.170 Falls nicht, dann prüfe ich weiter. 48:07.610 --> 48:09.270 Ist A kleiner als B? 48:09.750 --> 48:13.050 Wenn ja, gebe ich aus System.out.println, A ist kleiner als B. 48:13.050 --> 48:16.210 Und wenn das auch nicht der Fall ist, brauche ich jetzt nicht mehr 48:16.210 --> 48:19.030 prüfen, ist A gleich B, weil ich habe ja gerade schon größer und 48:19.030 --> 48:21.550 kleiner ausgeschlossen, also bleibt nur noch A ist gleich B. 48:21.670 --> 48:25.510 Das heißt, ich kann direkt ausgeben, System.out.println, A ist gleich 48:25.510 --> 48:25.810 B. 48:26.570 --> 48:30.050 Und um das machen zu können, der Vollständigkeit halber, muss ich 48:30.050 --> 48:32.990 diese beiden Integer-Eingaben auch erstmal einlesen. 48:33.050 --> 48:37.690 Das heißt, ich schreibe Scanner, Scanner ist ein neuer Scanner mit 48:37.690 --> 48:41.890 System.in, also soll von der Konsole einlesen, weise den ersten Wert, 48:41.990 --> 48:45.190 der eingegeben wird, der Variablen A zu und den zweiten Wert, der 48:45.190 --> 48:47.950 eingegeben wird, der Variablen B zu und dann kann ich eben das, was 48:47.950 --> 48:49.330 ich gerade beschrieben habe, hier machen. 48:49.830 --> 48:50.190 Genau. 48:51.730 --> 48:55.230 Das so als ganz grundlegende If-Verzweigung, das ist eben was, was Sie 48:55.230 --> 48:57.890 nach dieser Vorlesung gegebenenfalls mit ein bisschen Nachbereitung 48:57.890 --> 49:00.650 dann in der Lage sein sollten, zu machen. 49:01.130 --> 49:03.390 Und Sie können diese Codeschnipsel immer auch aus der Vorlesung 49:03.390 --> 49:06.630 herauskopieren und damit ein bisschen herumexperimentieren, wenn es 49:06.630 --> 49:09.510 Ihnen noch nicht klar ist, was das jetzt eigentlich oder wie das 49:09.510 --> 49:10.830 kommt, dass es so ist, wie es ist. 49:10.830 --> 49:13.930 Gut, kommen wir zur nächsten Fallunterscheidung. 49:14.010 --> 49:15.510 Jetzt gerade hatten wir das If-Else. 49:15.990 --> 49:19.330 Eine weitere Möglichkeit der Verzweigung in Java ist die sogenannte 49:19.330 --> 49:23.750 Switch -Anweisung, die ein bisschen praktischer ist dafür, wenn man 49:23.750 --> 49:25.310 viele Fälle unterscheiden möchte. 49:25.310 --> 49:34.190 Hier als Beispiel ein kleiner Programm-Code-Ausschnitt, der Kommandos 49:34.190 --> 49:36.450 unterscheiden soll. 49:36.690 --> 49:39.370 Also wir haben jetzt hier zum Beispiel einen Dateieditor oder sowas, 49:39.750 --> 49:43.650 der soll bei der Konsole, kann man ein Kommando eingeben als einzelne 49:43.650 --> 49:46.810 Zeichen, also zum Beispiel ein N, ein O, ein S oder ein Q. 49:47.210 --> 49:51.930 N soll stehen für irgendwas neu anlegen, O für Open, S für Save und Q 49:51.930 --> 49:52.370 für Quit. 49:52.830 --> 49:55.430 Und jetzt kann ich, wenn ich ein solches Programm schreibe, nehme ich 49:55.430 --> 49:59.090 mal an, ein Charakter, also ein Zeichen wird als Kommando eingegeben. 49:59.310 --> 50:01.870 Jetzt hier mal nicht weiter ausdifferenziert, damit es nicht zu lang 50:01.870 --> 50:03.490 wird, zum Beispiel über die Konsole. 50:03.490 --> 50:07.210 Und mit dieser Switch-Anweisung kann ich jetzt sagen, mache eine 50:07.210 --> 50:10.870 Fallunterscheidung für diesen übergebenen Charakter-Command. 50:11.450 --> 50:16.350 Wenn dieser Charakter den Wert new haben soll, new ist hier eine 50:16.350 --> 50:18.710 Konstante, haben wir beim letzten Mal darüber gesprochen mit dem 50:18.710 --> 50:23.830 Charakter N darin, das ist hier oben initialisiert, dann führe diese 50:23.830 --> 50:28.270 Anweisung aus, create new file und breche dann diese Switch-Anweisung 50:28.270 --> 50:29.490 ab, dafür steht es break. 50:30.230 --> 50:33.670 Weiter geht es hier dann, wenn der Fall ist, dass der Wert des 50:33.670 --> 50:38.650 Commands open ist, also hier ein O, dann öffne die Datei, also führe 50:38.650 --> 50:40.490 diese Anweisung aus und breche hier ab. 50:40.870 --> 50:46.070 Wenn der Fall save ist, also ein S, dann führe die Methode save file 50:46.070 --> 50:48.170 aus, also diese Anweisung, breche ab. 50:48.170 --> 50:52.910 Wenn der Fall ist, dass das Kommando quit, also ein Q übergeben ist, 50:54.810 --> 50:57.410 dann beende das Programm und höre dann hier auf. 50:57.910 --> 51:01.370 Und der Default-Fall, das gibt es bei einem Switch noch, also wenn 51:01.370 --> 51:05.610 keiner dieser Cases zu wahr ausgewertet wurde, dann gibt es optional 51:05.610 --> 51:08.990 noch ein Default, dann könnte ich ausgeben auf der Kommandozeile 51:08.990 --> 51:13.130 unbekanntes Kommando und dieses Kommando. 51:13.130 --> 51:15.930 Wenn jetzt also jemand für dieses kleine Beispielprogramm zum Beispiel 51:15.930 --> 51:20.410 ein Z eingibt, ist das weder ein N, noch ein O, noch ein S, noch ein Q 51:20.410 --> 51:23.430 und dann komme ich hier in diesen Default-Block des Switch-Statements 51:23.430 --> 51:27.710 hinein und gebe dann unbekanntes Kommando Doppelpunkt Z wieder aus und 51:27.710 --> 51:28.610 breche hier ab. 51:29.650 --> 51:32.290 Das ist ein Switch-Kommando, sieht ein bisschen aus wie dieses 51:32.290 --> 51:35.810 geschachtelte If-Else, aber ein bisschen sozusagen aufgeräumter und 51:35.810 --> 51:38.890 die unterschiedlichen Fälle auf Englisch Cases werden hier eben 51:38.890 --> 51:40.970 explizit unterschieden. 51:41.910 --> 51:46.010 Vom Beispiel eben kommen wir zum allgemeinen, wie sowas aussieht. 51:47.170 --> 51:50.750 Beim Switch ist die Syntax so, ich habe eben dieses Switch-Keyword, 51:50.970 --> 51:53.130 dahinter in Klammern einen Ausdruck. 51:53.630 --> 51:58.710 Dieser Ausdruck muss dabei den Typ Character, Byte, Short, Integer, 51:59.470 --> 52:01.190 Enum oder String haben. 52:01.190 --> 52:04.370 Es geht nicht beliebiges, ich kann keinen Ausdruck haben, der zum 52:04.370 --> 52:07.110 Beispiel ein Vektor 2D zurückliefert oder sowas, sondern nur diese 52:07.110 --> 52:07.490 Dinge hier. 52:08.210 --> 52:12.810 Und dann kann ich jeweils mit dem Keyword Case auch, kann auch über 52:12.810 --> 52:15.650 mehrere Zeilen sein, muss nicht wie hier in einer Zeile sein, aber das 52:15.650 --> 52:21.210 ist oft lesbarer in einer Zeile, über das Stichwort Case und dahinter 52:21.210 --> 52:26.210 einen möglichen Wert angeben, sagen, was quasi der Fall sein soll oder 52:26.210 --> 52:29.490 was ausgeführt werden soll, wenn der Ausdruck diesen ersten Wert 52:29.490 --> 52:29.950 annimmt. 52:30.550 --> 52:32.890 Zweiten Wert, dritten Wert, eigentlich so viele Werte, wie ich möchte, 52:33.050 --> 52:36.930 kann ich eben aufschreiben und ich kann weiterhin noch den Default, 52:37.610 --> 52:41.750 wenn keiner der vorherigen Cases zugeschlagen hat, was soll dann 52:41.750 --> 52:43.450 ausgeführt werden. 52:44.350 --> 52:48.350 Diese Werte noch dazu gesagt, hier müssen konstant sein, ich kann 52:48.350 --> 52:50.870 jetzt hier nicht eine Variable X verwenden, das würde nicht 52:50.870 --> 52:51.390 funktionieren. 52:52.910 --> 52:56.630 Ein bisschen eigentlich, ich würde jetzt vielleicht sagen, unschön ist 52:56.630 --> 52:59.890 es, das ist hier dieser Punkt, dass ein Case-Wert immer nur den 52:59.890 --> 53:02.450 Einstiegspunkt innerhalb des Switch-Blocks festlegt. 53:02.450 --> 53:07.430 Also wenn tatsächlich hier Wert 1 wahr ist und ich keine weiteren 53:07.430 --> 53:10.390 Break -Anweisungen benutze, dann werden danach auch die anderen 53:10.390 --> 53:13.430 Anweisungen, zum Beispiel die Anweisung N und diese Anweisung auch 53:13.430 --> 53:14.230 alle ausgeführt. 53:14.370 --> 53:17.910 Also es ist kein Entweder-Oder, sondern das Case hier ist immer nur 53:17.910 --> 53:21.470 ein Einstiegspunkt in das Switch und sofern ich keine Breaks 53:21.470 --> 53:24.830 weiterverwende, werden dann von da aus alle Anweisungen in dem Switch 53:24.830 --> 53:26.130 ausgeführt. 53:27.210 --> 53:28.170 Das steht hier unten. 53:28.790 --> 53:31.250 Also eine Break-Anweisung, wie wir es eben gesehen haben, führt dazu, 53:31.330 --> 53:33.170 dass ich an der Stelle den Switch-Block verlasse. 53:33.670 --> 53:36.810 Wenn ich keine Break-Anweisung verwende, dann werden auch die 53:36.810 --> 53:40.370 Anweisungen der jeweils nachfolgenden Case-Blöcke abgearbeitet. 53:40.430 --> 53:42.850 Das kann dazu führen, dass man Programme ein bisschen kürzer schreiben 53:42.850 --> 53:45.450 kann, sollte man aber eigentlich nicht machen, weil das ein bisschen 53:45.450 --> 53:47.890 unschön aussieht und schlecht wartbar ist. 53:47.890 --> 53:52.730 Und wenn ich eben keine Werte, die jetzt hier Wert 1 bis Wert N 53:52.730 --> 53:56.350 abgekürzt sind, wenn der Ausdruck keinen dieser Werte annimmt und ich 53:56.350 --> 53:59.210 einen Default-Block angegeben habe, dann wird dieser Default-Block 53:59.210 --> 53:59.870 ausgeführt. 54:00.290 --> 54:03.230 Ich kann aber auch einen Switch ohne Default-Block machen und falls 54:03.230 --> 54:05.170 dann keiner dieser Werte angenommen wird, dann passiert einfach 54:05.170 --> 54:05.410 nichts. 54:06.690 --> 54:08.310 Hier nochmal ein Beispiel. 54:09.290 --> 54:14.450 Unser Beispiel soll sein, dass wir für einen gegebenen Monat, der als 54:14.450 --> 54:18.410 Zahl zwischen 1 und 12 sozusagen kodiert ist, wissen wollen, wie viele 54:18.410 --> 54:19.650 Tage dieser Monat hat. 54:20.090 --> 54:23.110 Also wir fangen an mit einer Integer-Variable Monat, die setzen wir 54:23.110 --> 54:25.170 hier im Beispiel jetzt mal auf 5, aber das könnte natürlich was 54:25.170 --> 54:25.650 anderes sein. 54:25.650 --> 54:28.950 Wir wollen wissen, wie viele Tage der Monat hat und initialisieren 54:28.950 --> 54:33.950 diese Variable Tage erstmal mit 0 und können dann sagen, Switch Monat, 54:33.990 --> 54:38.470 Case 1, also Januar, dann soll die Variable Tage den Wert 31 bekommen 54:38.470 --> 54:42.290 und mit Break will ich dann hier die Ausführung des Switch-Blocks 54:42.290 --> 54:46.790 unterbrechen und dann hier mit meiner Programmausführung weitermachen. 54:46.790 --> 54:51.530 Case 2, also Februar, 28 Tage, wieder ein Break und so weiter. 54:51.930 --> 54:56.370 Das wäre jetzt also eine Auflistung explizit der zwölf Monate und in 54:56.370 --> 55:00.970 dem Case gebe ich jeweils an oder weise ich dann die korrekte Anzahl 55:00.970 --> 55:04.910 Tage für diesen Monat der Variablen Days zu und beende den Switch 55:04.910 --> 55:08.590 -Block am Ende jedes Cases mit Break, um dann nicht, wenn ich jetzt 55:08.590 --> 55:12.790 zum Beispiel sonst 11 eingeben würde und kein Break hätte, würde ich 55:12.790 --> 55:17.630 erst Days als zugewiesen bekommen, den Wert 30 ausführen und dann 55:17.630 --> 55:22.090 danach Days als zugewiesen bekommen den Wert 31 ohne Break. 55:22.290 --> 55:25.430 Wenn ich aber die Breaks benutze, wird immer nur eine dieser Zeilen 55:25.430 --> 55:28.330 ausgeführt, halt je nachdem welcher Fall hier eintritt. 55:30.490 --> 55:33.830 Das ist von daher die schönere Variante, die explizitere Variante. 55:33.930 --> 55:37.730 Man kann das auch, indem man die Breaks weglässt, so schreiben. 55:38.910 --> 55:45.430 Man kann schreiben Case 2, dann sollen die Tage 28 sein, der Februar 55:45.430 --> 55:46.450 hat ja nur 28 Tage. 55:46.450 --> 55:51.910 Dann schreibe ich untereinander auf Case 4, 6, 9 und 11, also April, 55:52.210 --> 55:54.210 Juni, September und November. 55:54.670 --> 55:56.470 Das sind die Monate mit 30 Tagen. 55:56.670 --> 55:59.210 Dann schreibe ich die alle untereinander und schreibe dann hierhin 55:59.210 --> 56:02.410 Days als zugewiesen bekommen den Wert 30 und gehe raus. 56:02.410 --> 56:07.470 Und der Default-Fall wäre, Days als zugewiesen bekommen den Wert 31 56:07.470 --> 56:08.330 und gehe wieder raus. 56:08.390 --> 56:10.630 Das könnten Sie jetzt im Kopf durchspielen mit den zwölf Monaten. 56:11.150 --> 56:13.450 Da kommt das gleiche raus wie auf der rechten Seite, aber das hier 56:13.450 --> 56:17.210 sieht natürlich sehr viel unklarer aus, was dieses Programm hier 56:17.210 --> 56:17.430 macht. 56:17.430 --> 56:21.470 Also geht auch und soll jetzt hier eben demonstrieren, was passiert, 56:21.530 --> 56:23.770 wenn man das Break nicht benutzt und wie dann ausgewertet wird. 56:24.010 --> 56:27.470 Zum Beispiel, wenn ich Juni 6 eingebe, komme ich hierhin, hier steht 56:27.470 --> 56:33.930 nichts, gehe ich halt weiter durch alle Cases, weise der Variante den 56:33.930 --> 56:36.750 Wert 30 zu und gehe mit dem Break dann aus dem Switch heraus. 56:36.750 --> 56:42.850 Aber wie gesagt, ist nicht so schön, schlechter lesbar. 56:43.230 --> 56:47.010 Hat auch noch den weiteren Nachteil, dass in diesem Fall auch für 56:47.010 --> 56:52.230 Werte kleiner 0 oder für den Wert 0 oder für Werte größer als 12 auch 56:52.230 --> 56:54.350 irgendwas gemacht wird, nämlich 31 zugewiesen. 56:55.050 --> 56:57.270 Und auch wenn man das hier im Nachhinein irgendwie ändern will, ist 56:57.270 --> 56:58.230 das unschön. 56:58.370 --> 57:02.230 Aber wie gesagt, ist ansonsten für die zwölf Monate das Gleiche und 57:02.230 --> 57:04.850 soll eben die verschiedene Art und Weise, wie man Switch verwenden 57:04.850 --> 57:05.750 kann, hier darstellen. 57:08.090 --> 57:11.690 Ein Hinweis noch, das hier ist jetzt eine sogenannte Switch-Anweisung 57:11.690 --> 57:14.190 gewesen, die es in Java schon lange gibt. 57:15.110 --> 57:20.270 Jetzt mit den neuen Java-Versionen ab Java 12 gibt es auch eine andere 57:20.270 --> 57:23.350 Art und Weise, Switches zu schreiben als sogenannte Switch-Ausdrücke. 57:24.410 --> 57:27.510 Das betrachten wir hier jetzt nicht, weil unser Praktomat, unser 57:27.510 --> 57:31.790 Übungsblatt -System nämlich nur bis Java 8 unterstützt. 57:32.210 --> 57:34.710 Deswegen brauchen Sie die neuen Switch-Ausdrücke in Ihrem 57:34.710 --> 57:37.910 Beispielprogramm gar nicht auszuprobieren oder würden dann 57:37.910 --> 57:39.630 entsprechende Fehlermeldungen vom Praktomaten bekommen. 57:40.190 --> 57:42.190 Also nur als Hinweis für diejenigen, die es interessiert, kann man 57:42.190 --> 57:42.710 sich anschauen. 57:42.710 --> 57:45.390 Aber wenn Sie einen Switch in Ihrem Programmcode verwenden wollen, in 57:45.390 --> 57:49.190 den Übungsaufgaben und in den Abschlussaufgaben, dann bitte diese Art 57:49.190 --> 57:51.630 hier des Switches als Switch-Anweisung. 57:52.990 --> 57:56.970 Gut, soviel zu den beiden verschiedenen Fallunterscheidungen, IF und 57:56.970 --> 57:57.290 Switch. 57:57.710 --> 58:01.570 Kommen wir jetzt zu dem, was ich vorhin schon motiviert habe, also das 58:01.570 --> 58:03.910 Wichtige, dass man auch richtig programmieren kann, nämlich den 58:03.910 --> 58:04.450 Schleifen. 58:06.050 --> 58:11.230 Schleifen erlauben es uns jetzt, Anweisungen wiederholt auszuführen. 58:11.350 --> 58:13.670 Und wir hatten ganz am Anfang in der Einführungsveranstaltung dieses 58:13.670 --> 58:16.830 Sortieren von Personen gehabt, wo eben auch verschiedene Schritte, 58:16.910 --> 58:19.070 wenn man das nach einem Sortieralgorithmus macht, auch immer wieder 58:19.070 --> 58:22.910 ausgeführt werden müssen, bis eben das Ergebnis sortiert ist zum 58:22.910 --> 58:23.270 Beispiel. 58:24.730 --> 58:27.690 Bei Schleifen kann man allgemein für die verschiedenen Typen von 58:27.690 --> 58:30.530 Schleifen, die wir gleich sehen werden, sagen, dass die Programmierung 58:30.530 --> 58:32.810 von Schleifen nach einem gewissen Muster erfolgt. 58:32.890 --> 58:35.410 Es ist nicht unbedingt alles bei allen Schleifentypen da, aber so 58:35.410 --> 58:35.930 prinzipiell. 58:36.350 --> 58:40.450 Ich kann eine Vorbereitung haben, dann die eigentlichen Anweisungen, 58:40.490 --> 58:42.970 die wiederholt werden sollen und gegebenenfalls noch eine 58:42.970 --> 58:44.930 Nachbereitung bei einer Schleife. 58:45.930 --> 58:49.110 Fangen wir aber direkt an mit dem ersten Typ von Schleife, nämlich der 58:49.110 --> 58:53.210 sogenannten While-Schleife, also auf Deutsch wäre das Während, eine 58:53.210 --> 58:53.890 Währendschleife. 58:54.630 --> 59:00.130 Genau, mit der While-Schleife, wie auch mit den anderen, kann ich sich 59:00.130 --> 59:03.430 wiederholende Ausführungen realisieren und als Beispiel könnten wir 59:03.430 --> 59:07.030 jetzt mal die Aufgabenstellung hier betrachten, dass wir die Summe von 59:07.030 --> 59:11.730 den Werten zwischen A und B berechnen wollen. 59:11.850 --> 59:16.070 Also hier die Summe von I, sollte den Wert A haben, hochgezählt, bis 59:16.070 --> 59:19.430 das I den Wert B haben soll. 59:19.870 --> 59:23.290 Das können wir als Schleife mit While hinschreiben, wie wir es hier 59:23.290 --> 59:24.050 unten getan haben. 59:24.090 --> 59:25.470 Ich springe jetzt mal direkt hier unten hin. 59:26.190 --> 59:27.830 Nein, wir kommen erst zu der Vorbereitung. 59:27.910 --> 59:31.130 Nehmen wir mal so an, wir haben eine Integer-Variable A, zum Beispiel, 59:31.290 --> 59:32.450 dass sie am Anfang den Wert 8 hat. 59:33.010 --> 59:36.150 Wir haben eine Integer-Variable B, die am Anfang den Wert 11 hat, 59:36.170 --> 59:37.350 jetzt in unserem konkreten Beispiel. 59:37.350 --> 59:41.450 Wir nehmen eine Integer-Variable I, ähnlich wie hier in der 59:41.450 --> 59:42.290 Summenformel. 59:42.710 --> 59:45.730 Die setzen wir initial auf den Wert A und das nennt man auch 59:45.730 --> 59:49.010 Vorbereitung dieser Schleife, weil so weiß die Schleife sozusagen, wo 59:49.010 --> 59:51.550 sie loslaufen soll, mit unter welchen Bedingungen sie loslaufen soll. 59:52.330 --> 59:55.090 Und eine zweite Vorbereitung ist noch, dass wir uns schon mal eine 59:55.090 --> 59:58.110 Variable für das Ergebnis anlegen, nämlich eine Variable Integer 59:58.110 --> 01:00:01.150 -Summe, die wir erst mal mit 0 initialisieren, wo wir dann aber das 01:00:01.150 --> 01:00:03.030 Ergebnis sukzessive drin berechnen wollen. 01:00:03.770 --> 01:00:07.390 Dann kommt hier die eigentliche Schleife und die schreibt man ein 01:00:07.390 --> 01:00:11.710 bisschen ähnlich wie ein if hin, man schreibt while, also während i 01:00:11.710 --> 01:00:15.470 kleiner gleich b ist, führe die folgenden Schritte, die in den 01:00:15.470 --> 01:00:16.810 geschweiften Klammern sind, aus. 01:00:16.810 --> 01:00:21.490 Also während i kleiner gleich b ist, berechne den neuen Wert von Summe 01:00:21.490 --> 01:00:27.630 als den alten Wert von Summe plus 1 und den neuen Wert von i als den 01:00:27.630 --> 01:00:29.150 alten Wert von i plus 1. 01:00:29.330 --> 01:00:31.670 Das sind also hier zwei Zuweisungen, die jeweils den Wert der 01:00:31.670 --> 01:00:33.750 Variablen um 1 hochzählen. 01:00:33.830 --> 01:00:37.490 Man hätte jetzt auch sum++ oder i++ verwenden können, aber jetzt hier 01:00:37.490 --> 01:00:38.150 mal ausgeschrieben. 01:00:39.270 --> 01:00:42.290 Genau, das sagt eben, man kann es auf Deutsch sicher vorstellen, 01:00:42.510 --> 01:00:44.530 während i kleiner gleich b ist. 01:00:45.910 --> 01:00:48.210 So eine Schleife wird jetzt auch für die Eingaben, die wir hier als 01:00:48.210 --> 01:00:51.570 Beispiel haben, eben so lange ausgeführt, bis diese Bedingung nicht 01:00:51.570 --> 01:00:53.850 mehr gilt und wir können uns jetzt hier in der Tabelle mal anschauen, 01:00:54.290 --> 01:00:57.630 wie diese Iterationen für dieses konkrete Beispiel hier aussehen 01:00:57.630 --> 01:00:57.890 würden. 01:00:57.890 --> 01:01:01.570 Also, wenn wir das ausführen, würden wir erstmal a und b 01:01:01.570 --> 01:01:02.210 initialisieren. 01:01:02.830 --> 01:01:06.990 Dann die Vorbereitung machen, dass wir diese Integervariablen i und 01:01:06.990 --> 01:01:11.910 Summe auch initialisieren und zwar mit den Werten i gleich 8, weil wir 01:01:11.910 --> 01:01:14.650 ja den Wert von a zuweisen und Summe auf 0 setzen. 01:01:14.650 --> 01:01:17.990 Und dann kommen wir in unsere Schleife hinein und prüfen in der ersten 01:01:17.990 --> 01:01:20.670 Iteration, ist i jetzt kleiner gleich b? 01:01:21.790 --> 01:01:22.730 Das ist der Fall. 01:01:24.190 --> 01:01:25.350 Genau, b ist ja 11. 01:01:25.930 --> 01:01:29.290 Also prüfen wir hier, ist i kleiner als b? 01:01:29.410 --> 01:01:30.910 Ist 8 kleiner als 11? 01:01:31.030 --> 01:01:31.330 Ja. 01:01:31.890 --> 01:01:35.070 Also gehen wir in den Schleifenrumpf hinein, ähnlich wie beim if und 01:01:35.070 --> 01:01:36.390 führen diese Anweisung aus. 01:01:36.390 --> 01:01:39.070 Die Summe soll um 1 erhöht werden, ach Entschuldigung, die Summe soll 01:01:39.070 --> 01:01:41.530 nicht um 1 erhöht werden, die Summe soll um i erhöht werden natürlich 01:01:41.530 --> 01:01:43.610 und i soll um 1 erhöht werden. 01:01:43.690 --> 01:01:44.530 Was passiert also? 01:01:46.330 --> 01:01:50.410 i soll um 1 erhöht werden, war vorher 8, wird dann 9 und die Summe war 01:01:50.410 --> 01:01:53.150 vorher 0, soll um i erhöht werden. 01:01:53.150 --> 01:01:54.430 Eigentlich andersherum. 01:01:54.570 --> 01:01:58.510 Erst berechne ich die alte Summe 0 plus i, was ja noch den Wert 8 hat 01:01:58.510 --> 01:02:01.730 und bekomme 8 heraus und danach führe ich diese Anweisung aus. 01:02:02.750 --> 01:02:07.850 i ist ja noch 8 plus 1 wird der neue Wert von i dann 9. 01:02:08.070 --> 01:02:11.230 Wenn ich also diese beiden Anweisungen abgearbeitet habe, habe ich 01:02:11.230 --> 01:02:16.210 dann die Werte i gleich 9 und Summe gleich 8 sozusagen in meiner 01:02:16.210 --> 01:02:17.130 variablen Belegung. 01:02:18.410 --> 01:02:21.330 Jetzt kommt das Wichtige, was man auf jeden Fall verstanden haben 01:02:21.330 --> 01:02:24.310 muss, wenn ich jetzt am Ende sozusagen dieses Blocks innerhalb der 01:02:24.310 --> 01:02:27.470 Schleife angekommen bin, hier an dieser geschweiften Klammer, dann 01:02:27.470 --> 01:02:30.950 gehe ich wieder hoch zum Anfang der Schleife, dann prüfe ich also 01:02:30.950 --> 01:02:34.750 erneut, ist diese Bedingung noch gültig, also während i kleiner gleich 01:02:34.750 --> 01:02:35.270 b ist. 01:02:35.270 --> 01:02:38.850 Jetzt prüfe ich jetzt wieder, jetzt hat i den Wert 9, b hat immer noch 01:02:38.850 --> 01:02:41.190 den Wert 11, also i ist immer noch kleiner als b. 01:02:41.650 --> 01:02:43.810 Das heißt, ich gehe wieder in den Schleifenrumpf hinein in meiner 01:02:43.810 --> 01:02:47.470 zweiten Iteration, der zweiten Wiederholung der Schleife, setze dann 01:02:47.470 --> 01:02:51.990 Summe jetzt auf den alten Wert von Summe, das war 8 plus i, das ist 01:02:51.990 --> 01:02:54.650 jetzt 9 und komme dann auf 17. 01:02:54.650 --> 01:03:00.710 Und in der zweiten Anweisung hier zähle ich i wieder um 1 hoch, i hat 01:03:00.710 --> 01:03:01.870 danach den Wert 10. 01:03:02.970 --> 01:03:05.310 Die Spalten hätten wir vielleicht besser andersrum schreiben sollen, 01:03:05.410 --> 01:03:05.710 aber egal. 01:03:06.930 --> 01:03:11.730 Also diese Iteration hier zeigt immer den Wert nach der Ausführung der 01:03:11.730 --> 01:03:14.310 beiden Anweisungen im Schleifenrumpf. 01:03:14.870 --> 01:03:17.650 Also dieses hier zwischen den beiden geschweiften Klammern nennt man 01:03:17.650 --> 01:03:18.790 dann auch den Schleifenrumpf. 01:03:20.550 --> 01:03:23.290 Dann komme ich in die dritte Iteration, ich prüfe wieder, ist i immer 01:03:23.290 --> 01:03:24.090 noch kleiner als b? 01:03:24.170 --> 01:03:29.150 Das ist immer noch der Fall, i ist 10, b ist 11. 01:03:29.510 --> 01:03:31.830 Also das ist der Fall, ich gehe wieder in den Schleifenrumpf hinein 01:03:31.830 --> 01:03:33.670 und rechne meine Zahlen entsprechend zusammen. 01:03:34.090 --> 01:03:39.410 Summe ist jetzt 17 plus 10, 27 und 11, das i wird um 1 erhöht. 01:03:40.110 --> 01:03:43.890 Wir gehen wieder nach oben, überprüfen wieder, ist die Bedingung immer 01:03:43.890 --> 01:03:47.890 noch erfüllt, i kleiner gleich b, 11 ist kleiner als b, also gehen wir 01:03:47.890 --> 01:03:52.030 nochmal in den Schleifenrumpf hinein in der vierten Iteration, rechnen 01:03:52.030 --> 01:03:57.410 27 plus 11 ist 38, das wird in Summe abgelegt und die Variable i wird 01:03:57.410 --> 01:03:58.670 wieder um 1 hochgezählt. 01:03:59.450 --> 01:04:03.050 Dann gehen wir wieder nach oben, überprüfen, ob unsere Bedingung noch 01:04:03.050 --> 01:04:03.310 gilt. 01:04:03.910 --> 01:04:07.270 Jetzt haben wir i 12, b 11, die Bedingung gilt also nicht mehr. 01:04:07.650 --> 01:04:11.050 Das heißt, wir beenden diese Schleife an dem Punkt dann eben, wo die 01:04:11.050 --> 01:04:13.550 Bedingung nicht mehr gilt und würden jetzt hier unten weiter 01:04:13.550 --> 01:04:14.730 ausführen, wenn hier noch was wäre. 01:04:15.150 --> 01:04:17.690 Das Ergebnis in der variablen Summe ist dann 38. 01:04:21.450 --> 01:04:22.290 Jetzt Sie. 01:04:25.180 --> 01:04:27.580 Sie haben jetzt gesehen, wie so eine Wildschleife funktioniert in 01:04:27.580 --> 01:04:28.460 diesem kleinen Beispiel. 01:04:28.580 --> 01:04:33.460 Es ist ja auch einigermaßen ähnlich wie so eine If-Bindeverzweigung. 01:04:33.900 --> 01:04:36.560 Jetzt können Sie direkt mal versuchen, selber ein Programm oder ein 01:04:36.560 --> 01:04:41.080 Programm -Schnipsel zu schreiben, das für eine Integer-Eingabe p die 01:04:41.080 --> 01:04:43.920 Zahlen von 1 bis p ausgibt. 01:04:44.740 --> 01:04:49.880 Das heißt, wenn wir jetzt zum Beispiel den Wert 5 eingeben, also die 01:04:49.880 --> 01:04:54.220 Variable p den Wert 5 am Anfang hat, dann möchten wir die Ausgaben 1, 01:04:54.300 --> 01:04:58.680 2, 3, 4, 5 haben und dazu kann man jetzt eben eine Schleife verwenden, 01:04:58.740 --> 01:05:01.820 um das zu programmieren und das können Sie jetzt in den nächsten drei 01:05:01.820 --> 01:05:02.940 Minuten mal versuchen. 01:05:02.940 --> 01:05:06.520 Wie gesagt, genauso wie eben, erst mal für sich und dann gerne im 01:05:06.520 --> 01:05:07.500 Austausch mit dem Nachbarn. 01:05:09.200 --> 01:05:09.840 Nein, doch. 01:05:16.460 --> 01:05:18.300 Neun nach, haben wir es jetzt so bis zwölf nach. 01:05:19.080 --> 01:05:21.980 Gut, wir haben es auch schon zwölf nach, ob es jetzt genau drei 01:05:21.980 --> 01:05:25.340 Minuten waren, aber zumindest ist es jetzt zwölf nach. 01:05:25.340 --> 01:05:29.000 Ich hoffe, Sie alle konnten sich eine gewisse Lösungsidee überlegen an 01:05:29.000 --> 01:05:29.500 dieser Stelle. 01:05:29.720 --> 01:05:32.720 Also diese Übungsaufgaben in der Vorlesung sollen ja immer Ihnen 01:05:32.720 --> 01:05:35.240 ermöglichen, direkt zu reflektieren, was habe ich da gerade gehört, 01:05:35.360 --> 01:05:38.380 weil sonst lässt man sich so berieseln in der Vorlesung und dann hat 01:05:38.380 --> 01:05:39.460 man es danach gleich wieder vergessen. 01:05:39.960 --> 01:05:42.240 Das geht aber hier nicht, denn das ist sowas von grundlegend. 01:05:42.280 --> 01:05:44.520 Das brauchen Sie auf jeden Fall, um Übungsaufgaben und 01:05:44.520 --> 01:05:47.260 Abschlussaufgaben dann auch bearbeiten zu können. 01:05:48.540 --> 01:05:50.660 Gut, wie gehen wir hier vor? 01:05:50.820 --> 01:05:54.160 Ich blende direkt mal die Lösung wieder ein, die wir hier oder die ich 01:05:54.160 --> 01:05:56.740 hier als Musterlösung entwickelt habe oder die hier steht. 01:05:57.620 --> 01:06:00.420 Das Wichtige, also auch hier jetzt wieder ist es nicht wichtig, ob 01:06:00.420 --> 01:06:03.940 Sie, wenn Sie es jetzt auf Papier gelöst haben, diese Mikrolands alle 01:06:03.940 --> 01:06:07.220 richtig hatten oder noch wussten, dass man mit System.in auf die 01:06:07.220 --> 01:06:10.040 Konsole zugreifen kann, sondern das Wichtige hier an der Stelle ist 01:06:10.040 --> 01:06:12.840 diese Schleife und auch die Vorbereitung der Schleife. 01:06:12.840 --> 01:06:16.000 Also irgendwo muss ich erst mal die Variable P herhaben. 01:06:16.040 --> 01:06:17.880 Da hatten wir ja gesagt, das ist eine Integereingabe. 01:06:18.380 --> 01:06:19.840 Scanner NextInt kennen wir dafür. 01:06:20.540 --> 01:06:22.740 Die Vorbereitung ist dann auch wichtig der Schleife. 01:06:22.860 --> 01:06:27.480 Ich muss mir nämlich, wenn ich diese Ausgabe machen will, eine 01:06:27.480 --> 01:06:30.800 sogenannte Schleifenvariable auch überlegen, die sozusagen mitzählt. 01:06:31.340 --> 01:06:34.960 Oder wo bin ich jetzt gerade in meiner Schleife und was muss ich als 01:06:34.960 --> 01:06:35.760 nächstes ausgeben? 01:06:36.660 --> 01:06:39.700 Die würde ich jetzt erst mal, weil wir hier als erstes eine 1 ausgeben 01:06:39.700 --> 01:06:43.120 wollen, vorbereitend auf den Wert 1 initialisieren. 01:06:44.200 --> 01:06:46.960 Und dann habe ich eigentlich auch schon das Wichtigste geschafft, die 01:06:46.960 --> 01:06:48.140 wichtigste Lösungsidee geschafft. 01:06:48.140 --> 01:06:53.080 Dann kann ich nämlich sagen, solange i kleiner gleich p ist, habe ich 01:06:53.080 --> 01:06:53.660 eine Schleife. 01:06:53.800 --> 01:06:58.240 Ich gebe i aus und ein Leerzeichen, damit ich das hier so ausgegeben 01:06:58.240 --> 01:07:01.600 bekomme und inkrementiere dann i um 1. 01:07:01.740 --> 01:07:03.140 Also das ist wieder das Gleiche wie eben. 01:07:03.220 --> 01:07:06.260 Ich könnte auch i gleich i plus 1 schreiben oder ich kann eben i plus 01:07:06.260 --> 01:07:06.800 plus schreiben. 01:07:09.340 --> 01:07:12.380 Jetzt bitte wieder die Aufmerksamkeit hier vorne hin richten. 01:07:12.440 --> 01:07:15.520 Ich höre noch einige Diskussionen, hoffentlich über Ihre jeweiligen 01:07:15.520 --> 01:07:15.960 Lösungen. 01:07:16.520 --> 01:07:22.180 Aber wie gesagt, im Interesse Ihrer Kommilitonen bitte die 01:07:22.180 --> 01:07:23.580 Unterhaltung auch später verschieben. 01:07:24.740 --> 01:07:26.280 In der Mensa waren Sie eigentlich alle gerade erst. 01:07:26.360 --> 01:07:27.740 Da haben Sie doch bestimmt schon ganz viel geredet, oder? 01:07:28.600 --> 01:07:29.160 Aber gut. 01:07:29.700 --> 01:07:30.600 Okay, also hier das Wichtige. 01:07:32.000 --> 01:07:34.460 Hätte ich jetzt nicht sagen sollen, jetzt diskutieren Sie den 01:07:34.460 --> 01:07:35.040 Kommentar. 01:07:35.340 --> 01:07:36.580 Hier das Wichtige, diese Schleife. 01:07:36.860 --> 01:07:37.840 Ich brauche eine Vorbereitung. 01:07:37.940 --> 01:07:39.640 Ich muss mir irgendwie überlegen, wo fange ich jetzt an. 01:07:40.100 --> 01:07:43.140 Dann eine Bedingung, die ich prüfe und etwas, was ich typischerweise 01:07:43.140 --> 01:07:45.700 nicht immer, aber typischerweise zum Beispiel hochzähle. 01:07:45.780 --> 01:07:47.780 Also hier fange ich an, i soll am Anfang 1 sein. 01:07:47.860 --> 01:07:49.260 Ich prüfe, ist i kleiner gleich p? 01:07:49.260 --> 01:07:53.740 Wenn ja, dann führe ich solange diese zwei Anweisungen aus, gebe i aus 01:07:53.740 --> 01:07:59.160 mit einem Leerzeichen dahinter, inkrementiere i um 1, bis i dann 01:07:59.160 --> 01:08:00.960 irgendwann den Wert 6 hat. 01:08:01.400 --> 01:08:04.080 Dann gilt diese Bedingung hier nicht mehr und ich verlasse die 01:08:04.080 --> 01:08:04.520 Schleife. 01:08:04.980 --> 01:08:06.640 In dem Fall ist dann jetzt auch unser Programm zu Ende. 01:08:07.720 --> 01:08:07.840 Genau. 01:08:08.240 --> 01:08:09.360 Wieder der Vollständigkeit habe. 01:08:09.500 --> 01:08:10.980 Ein Scanner muss natürlich irgendwo herkommen. 01:08:11.060 --> 01:08:13.680 Den würde ich dann hier in der ersten Zeile entsprechend als neues 01:08:13.680 --> 01:08:15.520 Objekt erzeugen, dass ich damit arbeiten kann. 01:08:17.540 --> 01:08:22.440 Weil ist, wie gesagt, eine Form der Schleife, aber genau, die gucken 01:08:22.440 --> 01:08:24.120 wir uns jetzt erstmal an, wie die Syntax ist. 01:08:24.560 --> 01:08:27.160 Ähnlich wie bei der If-Anweisung, bloß mit eben dieser Bedeutung, dass 01:08:27.160 --> 01:08:28.940 man Dinge wiederholt, solange die Bedingung gilt. 01:08:29.400 --> 01:08:32.100 Ich habe also while in Klammern dann eine Bedingung, also einen 01:08:32.100 --> 01:08:36.220 Ausdruck vom Typ Boolean und dann in geschweiften Klammern eine oder 01:08:36.220 --> 01:08:40.440 mehrere Anweisungen, die es eben in jeder Schleifeniteration oder die 01:08:40.440 --> 01:08:42.740 in jeder Schleifeniteration ausgeführt werden sollen. 01:08:43.460 --> 01:08:46.700 Es gibt auch noch eine ähnliche Schleife, die sogenannte Do-While 01:08:46.700 --> 01:08:47.200 Schleife. 01:08:47.760 --> 01:08:50.680 Ich kann auch das Schlüsselwort Do zuerst schreiben, dann den Block 01:08:50.680 --> 01:08:55.480 mit Anweisung und dahinter dann ein While Bedingung schreiben. 01:08:55.620 --> 01:08:58.320 Das ist ähnlich wie die While Schleife, ein bisschen anders und den 01:08:58.320 --> 01:09:01.160 Unterschied können wir uns hier anhand der Kontrollschlussdiagramme 01:09:01.160 --> 01:09:01.720 klar machen. 01:09:02.180 --> 01:09:04.220 Zunächst einmal der Kontrollschlussdiagramm für While. 01:09:04.220 --> 01:09:08.080 Ich starte, ich prüfe die Bedingung, wenn die Bedingung false ist, 01:09:08.120 --> 01:09:12.420 dann beende ich sozusagen die While Schleife, die ist While Statement. 01:09:12.860 --> 01:09:15.840 Wenn die Bedingung wahr ist, dann führe ich die Anweisung in meinem 01:09:15.840 --> 01:09:19.360 Schleifenrumpf aus, eine oder mehrere und gehe dann wieder zurück und 01:09:19.360 --> 01:09:20.640 prüfe die Bedingung erneut. 01:09:20.800 --> 01:09:23.220 Wenn die dann immer noch wahr ist, führe ich die Anweisung im 01:09:23.220 --> 01:09:26.460 Schleifenrumpf nochmals aus, überprüfe wieder die Bedingung und das 01:09:26.460 --> 01:09:29.900 eben solange, bis die Bedingung einmal an der Stelle zu falsch 01:09:29.900 --> 01:09:31.940 ausgewertet ist und ich die Schleife beende. 01:09:32.640 --> 01:09:36.560 Die Do-While Schleife ist so ähnlich, da ist es bloß so, dass am Start 01:09:36.560 --> 01:09:40.540 immer zuerst die Anweisungen ausgeführt werden und danach bei dem 01:09:40.540 --> 01:09:44.520 While hinter dem Schleifenrumpf erst die Bedingung überprüft wird. 01:09:44.580 --> 01:09:46.720 Wenn die Bedingung wahr ist, gehe ich wieder nach oben und führe die 01:09:46.720 --> 01:09:50.340 Anweisung erneut aus und wenn die Bedingung halt hier falsch ist, 01:09:50.500 --> 01:09:51.500 beende ich die Schleife. 01:09:51.500 --> 01:09:54.380 Jetzt würden Sie vielleicht auf den ersten Blick sagen, das ist doch 01:09:54.380 --> 01:09:57.560 irgendwie das Gleiche, aber vielleicht sehen Sie auch den Unterschied 01:09:57.560 --> 01:09:59.560 an dieser Stelle. 01:10:01.380 --> 01:10:03.620 Das ist nämlich nicht immer das Gleiche. 01:10:04.400 --> 01:10:08.020 Der Unterschied zwischen While und Do-While ist, dass es auch möglich 01:10:08.020 --> 01:10:11.240 ist, eine While Schleife sozusagen nullmal zu durchlaufen, wenn 01:10:11.240 --> 01:10:13.500 nämlich am Start die Bedingung gleich falsch ist, dann gehe ich gleich 01:10:13.500 --> 01:10:15.620 schon wieder raus und die Anweisungen werden nie ausgeführt, 01:10:16.140 --> 01:10:19.200 wohingegen bei der Do-While Schleife die Anweisungen immer mindestens 01:10:19.200 --> 01:10:21.880 einmal ausgeführt werden und ich danach dann ja erst die Bedingung 01:10:21.880 --> 01:10:22.240 prüfe. 01:10:24.140 --> 01:10:28.360 Die dritte Schleife und die ist, wenn man sie benutzen kann, weil sie 01:10:28.360 --> 01:10:31.700 passt eigentlich ein bisschen schöner als die While Schleife, ist die 01:10:31.700 --> 01:10:33.020 sogenannte For Schleife. 01:10:33.180 --> 01:10:37.680 Das ist gedacht gewesen in Java als Zählschleife, dass man sagt, für 01:10:37.680 --> 01:10:41.360 eine bestimmte Anzahl von Elementen zum Beispiel möchte ich die alle 01:10:41.360 --> 01:10:41.820 durchgehen. 01:10:42.420 --> 01:10:46.560 Die Syntax ist ein bisschen komplizierter und muss man sich ein 01:10:46.560 --> 01:10:47.240 bisschen dran gewöhnen. 01:10:47.840 --> 01:10:52.020 Das Schlüsselwort for, dann in Klammern aber ein bisschen mehr, nicht 01:10:52.020 --> 01:10:55.360 nur eine Bedingung und dahinter aber wieder wie gewohnt bei der While 01:10:55.360 --> 01:10:57.540 Schleife eine Menge von Anweisungen, die den Schleifenrumpf 01:10:57.540 --> 01:10:58.020 beschreiben. 01:10:58.020 --> 01:11:00.080 Aber schauen wir uns diesen Teil nochmal an. 01:11:00.720 --> 01:11:03.160 Hier steht bei der For Schleife eben nicht nur eine Bedingung, sondern 01:11:03.160 --> 01:11:06.880 es steht eine Initialisierung mit Semikolon getrennt von einer 01:11:06.880 --> 01:11:09.420 Bedingung, wieder ein Semikolon und ein sogenannter Schritt. 01:11:11.140 --> 01:11:13.700 Das ist so gedacht, dass man bei der For Schleife diese 01:11:13.700 --> 01:11:16.280 Schleifenvorbereitung, die wir bei der While Schleife in der Zeile 01:11:16.280 --> 01:11:20.200 drüber gemacht haben, auch mit in die For Schleife hineinnehmen kann. 01:11:20.680 --> 01:11:23.700 Also es ist eine Anweisung, die einmal nur am Anfang der Schleife 01:11:23.700 --> 01:11:24.580 ausgeführt wird. 01:11:25.460 --> 01:11:28.400 Diese Initialisierung nicht pro Iteration, sondern nur einmal. 01:11:28.400 --> 01:11:31.020 Die Bedingung ist wieder das, was wir in der While Schleife kennen, 01:11:31.120 --> 01:11:35.120 das wird nach jeder Schleifeniteration ausgeführt und Schritt ist eine 01:11:35.120 --> 01:11:39.500 Anweisung, die am Ende jedes Schleifendurchlaufs ausgeführt wird, nach 01:11:39.500 --> 01:11:40.780 den Anweisungen, die hier kommen. 01:11:41.240 --> 01:11:44.440 Also wenn ich sowas durchlaufe, wird beim ersten Mal Initialisierung 01:11:44.440 --> 01:11:48.480 ausgeführt, Bedingung geprüft, wenn wahr, dann Anweisung ausgeführt, 01:11:48.840 --> 01:11:52.180 dann Schritt, dann wieder Bedingung geprüft, wenn wahr, dann Anweisung 01:11:52.180 --> 01:11:54.780 ausgeführt, dann Schritt und dann zum Beispiel wieder Bedingung 01:11:54.780 --> 01:11:56.700 geprüft, die dann falsch ist und dann beende ich. 01:11:56.700 --> 01:11:59.580 Also von daher ein bisschen, wie gesagt, komplizierter. 01:11:59.880 --> 01:12:04.240 Als Beispiel hier, wenn ich wieder aufsummieren möchte, die Zahlen von 01:12:04.240 --> 01:12:08.040 8 bis 11, Summe wird auf 0 initialisiert, dann kann ich jetzt hier 01:12:08.040 --> 01:12:16.120 dieses Int I, soll zugewiesen werden, den Wert von A in die Schleife 01:12:16.120 --> 01:12:19.360 als Initialisierung hineinziehen, habe dann hier die Bedingung, ob I 01:12:19.360 --> 01:12:22.460 kleiner gleich B ist und kann dann diesen Schritt, also das I 01:12:22.460 --> 01:12:24.360 hochzählen, hier hinten machen. 01:12:24.360 --> 01:12:26.680 Das ist also ein Schritt, der gleichartig ist bei jeder 01:12:26.680 --> 01:12:29.820 Schleifeniteration und kann dann quasi als Schleifenrumpf dann 01:12:29.820 --> 01:12:33.560 schreiben, Summe soll den alten Wert von Summe plus I sein. 01:12:33.640 --> 01:12:35.780 Das ist also das Gleiche, was wir eben bei der Wildschleife gesehen 01:12:35.780 --> 01:12:38.360 haben, nur jetzt als Vorschleife geschrieben. 01:12:39.460 --> 01:12:41.500 Wie sieht da der Kontrollfluss aus? 01:12:41.780 --> 01:12:44.600 Wie ich es gerade erklärt habe, am Anfang wird einmal die 01:12:44.600 --> 01:12:48.740 Initialisierungsanweisung ausgeführt, dann die Bedingung geprüft, wenn 01:12:48.740 --> 01:12:51.480 die falsch ist, beende ich direkt, wenn sie wahr ist, führe ich die 01:12:51.480 --> 01:12:56.220 Anweisung aus, danach führe ich diese Schrittanweisung aus und prüfe 01:12:56.220 --> 01:12:57.520 dann die Bedingung erneut. 01:13:02.080 --> 01:13:04.620 Interessant ist, sich anzuschauen, wofür das eigentlich gut ist. 01:13:04.700 --> 01:13:06.940 Warum gibt es eigentlich zwei Schleifen, die das Gleiche können? 01:13:07.000 --> 01:13:09.180 Wir haben ja jetzt gerade das gleiche Beispiel mit beiden Schleifen 01:13:09.180 --> 01:13:10.440 gemacht. 01:13:10.780 --> 01:13:12.500 Hier nochmal der Vergleich, wie das aussieht. 01:13:13.000 --> 01:13:16.160 Bei der Wildschleife habe ich eben typischerweise eine Initialisierung 01:13:16.160 --> 01:13:19.380 davor, nicht notwendigerweise, aber bei vielen Problemen ist das 01:13:19.380 --> 01:13:22.660 sinnvoll, habe dann hier eine Abbruchbedingung bzw. 01:13:22.920 --> 01:13:25.760 eine Bedingung, die halt gelten muss, solange ich die Schleife 01:13:25.760 --> 01:13:28.240 ausführe und dann eine Menge von Anweisungen. 01:13:28.960 --> 01:13:31.860 Typischerweise, wenn ich sowas mache, wie eben mit unserer Summe, ist 01:13:31.860 --> 01:13:35.440 eine der Anweisungen so etwas wie eine Zählvariable I hochzählen. 01:13:35.840 --> 01:13:39.060 Muss nicht sein bei Wildschleifen, aber bei solchen Problemen, wie wir 01:13:39.060 --> 01:13:41.580 sie eben hatten, so eine Summe bilden, habe ich sowas typisch. 01:13:41.580 --> 01:13:45.080 Bei einer Vorschleife sind eben diese Dinge, die ich typischerweise 01:13:45.080 --> 01:13:47.880 mache bei einer Wildschleife, nämlich diese Initialisierung und diese 01:13:47.880 --> 01:13:51.420 Schrittanweisung in die Schleife selber hier in diese Klammer 01:13:51.420 --> 01:13:53.960 hineingezogen, weil das eben typischerweise zu einer Schleife 01:13:53.960 --> 01:13:54.520 dazugehört. 01:13:55.260 --> 01:13:58.240 Und so kann ich dann als Programmierer auch leicht erkennen, was ist 01:13:58.240 --> 01:14:01.580 denn das Gemeinsame über diese verschiedenen Schleifeniterationen. 01:14:02.800 --> 01:14:06.160 Und innen drin habe ich dann sozusagen nur noch den Code, der eben 01:14:06.160 --> 01:14:08.360 innerhalb einer Schleifeniteration ausgeführt werden soll. 01:14:08.880 --> 01:14:15.960 Das ist eigentlich in C, also zunächst in C, was ja die älteste 01:14:15.960 --> 01:14:18.540 Programmiersprache dieser drei hier ist und dann in C++ und dann in 01:14:18.540 --> 01:14:18.820 Java. 01:14:19.240 --> 01:14:21.300 Man könnte auch sagen, ein bisschen schief gelaufen, weil was man 01:14:21.300 --> 01:14:24.140 eigentlich erreichen wollte, ist zu sagen, ich habe zwei verschiedene 01:14:24.140 --> 01:14:25.140 Arten von Schleifen. 01:14:25.680 --> 01:14:27.480 Die eine ist eine Vorschleife. 01:14:27.620 --> 01:14:30.140 Ich habe gegeben zum Beispiel eine Anzahl von Elementen und durch die 01:14:30.140 --> 01:14:30.920 will ich durchgehen. 01:14:30.920 --> 01:14:34.380 Ich weiß eigentlich vorher schon, wie oft ich das machen will, zum 01:14:34.380 --> 01:14:36.700 Beispiel fünfmal oder siebenmal, wie auch immer. 01:14:36.820 --> 01:14:41.060 Ich will irgendwas, eine bestimmte Anzahl von Malen wiederholen und 01:14:41.060 --> 01:14:42.620 einfach nur nicht einmal hinschreiben. 01:14:43.540 --> 01:14:45.520 Und dafür ist eigentlich diese Vorschleife gedacht. 01:14:45.820 --> 01:14:48.560 Also ich weiß wie oft, zum Beispiel, weil ich eine Anzahl von 01:14:48.560 --> 01:14:51.020 Elementen habe, die ich durchgehen will, will ich dann für jedes 01:14:51.020 --> 01:14:52.820 Element zum Beispiel eine Anweisung ausführen. 01:14:53.420 --> 01:14:56.280 Und die While-Schleife ist eigentlich eher für Schleifen gedacht, wo 01:14:56.280 --> 01:14:59.900 die Anzahl der Wiederholungen noch im Voraus nicht so ganz klar sind. 01:14:59.900 --> 01:15:04.180 Also wo im Schleifenrumpf interessante Dinge passieren und ich muss 01:15:04.180 --> 01:15:07.560 dann quasi nach jeder Schleifenausführung prüfen, bin ich jetzt fertig 01:15:07.560 --> 01:15:08.020 oder nicht. 01:15:08.420 --> 01:15:10.060 Dafür ist die While-Schleife eigentlich gedacht. 01:15:10.540 --> 01:15:13.800 Dummerweise sind sowohl die Vorschleife als auch die While-Schleife 01:15:13.800 --> 01:15:15.480 jetzt eigentlich eher der zweite Fall. 01:15:16.500 --> 01:15:20.260 Weil ich nämlich auch in Java in der Vorschleife hier hinten beliebige 01:15:20.260 --> 01:15:23.580 Sachen reinschreiben kann und dann gar nicht unbedingt wirklich von 01:15:23.580 --> 01:15:26.520 vornherein feststeht, wie oft diese Schleife durchlaufen wird. 01:15:27.440 --> 01:15:31.780 Genau, das habe ich jetzt eigentlich gerade gesagt. 01:15:33.000 --> 01:15:35.940 Das also, wenn ich weiß, eigentlich weiß, wie oft, dann benutzt man 01:15:35.940 --> 01:15:39.340 aber auch in Java typischerweise diese Vorschleife und bei der While 01:15:39.340 --> 01:15:42.700 -Schleife, die benutze ich eher, wenn ich nicht unbedingt weiß, wie 01:15:42.700 --> 01:15:44.560 oft der Schleifenrumpf ausgeführt werden soll. 01:15:47.100 --> 01:15:49.940 Diese While-Schleife ist auch der Grund, warum ich nicht im 01:15:49.940 --> 01:15:52.640 Allgemeinen entscheiden kann, ob ein Programm überhaupt mal irgendwann 01:15:52.640 --> 01:15:53.540 fertig ist oder nicht. 01:15:53.620 --> 01:15:54.980 Das ist das sogenannte Halteproblem. 01:15:55.680 --> 01:15:57.440 Kommen Sie an anderer Stelle dann auch mal drauf. 01:15:57.860 --> 01:16:01.000 Was aber ja auch besagt, es gibt keinen Algorithmus, der entscheidet, 01:16:01.140 --> 01:16:03.540 ob ein Programm mit While-Schleifen im Allgemeinen irgendwann 01:16:03.540 --> 01:16:05.660 überhaupt mal aufhört und fertig wird. 01:16:06.280 --> 01:16:07.360 Das aber am Rande erwähnt. 01:16:09.640 --> 01:16:12.660 Mittlerweile ab Java 8 gibt es auch eine sogenannte For-Each-Schleife, 01:16:12.780 --> 01:16:15.520 die das versucht, noch ein bisschen expliziter zu machen, dass man 01:16:15.520 --> 01:16:18.180 manchmal bei Vorschleifen einfach nur durchzählen will und nicht so 01:16:18.180 --> 01:16:20.600 unklar ist, wann diese Schleife aufhört. 01:16:22.360 --> 01:16:23.560 Ein Beispiel jetzt nochmal. 01:16:23.880 --> 01:16:26.300 Sie fragen sich jetzt vielleicht, Moment, das war doch immer klar, wie 01:16:26.300 --> 01:16:27.740 oft man durch die Schleifen durchlaufen soll. 01:16:27.800 --> 01:16:30.440 Wenn ich zum Beispiel von 8 bis 11 aufsummieren will, dann war es 01:16:30.440 --> 01:16:31.420 glaube ich dreimal oder so. 01:16:32.080 --> 01:16:34.600 Hier ist mal kurz ein Beispiel für einen Algorithmus, wo nicht klar 01:16:34.600 --> 01:16:39.500 ist im Voraus, wie oft ich diesen Schleifenrumpf durchlaufen will. 01:16:39.580 --> 01:16:41.020 Das ist das sogenannte Kollatzproblem. 01:16:41.220 --> 01:16:43.220 Hier der Link auf die Wiki-Seite, da ist das nochmal erklärt. 01:16:43.820 --> 01:16:45.980 Einfach so eine mathematische Überlegung. 01:16:45.980 --> 01:16:49.360 Was passiert eigentlich, wenn ich mir eine Folge von natürlichen 01:16:49.360 --> 01:16:51.900 Bezahlen betrachte mit einer beliebigen Startzahl n? 01:16:52.320 --> 01:17:01.320 Wenn n gerade ist, dann teile ich n durch 2 und wenn n nicht gerade 01:17:01.320 --> 01:17:03.200 ist, dann rechne ich n mal 3 plus 1. 01:17:03.400 --> 01:17:05.480 Und so kann ich mir eine Folge von Zahlen aufbauen. 01:17:05.480 --> 01:17:11.500 Und diese Kollatzvermutung ist, dass diese, egal welche Zahl n ich am 01:17:11.500 --> 01:17:19.260 Ende nehme, am Ende wird diese Folge immer zu 4, 2, 1 sozusagen da 01:17:19.260 --> 01:17:19.620 enden. 01:17:19.740 --> 01:17:23.200 Also ob ich jetzt mit 1050 anfange oder mit 3 anfange, wenn ich diese 01:17:23.200 --> 01:17:28.480 Berechnung mache, werde ich am Ende immer dann irgendwann den Wert n 01:17:28.480 --> 01:17:32.800 gleich 4, danach n gleich 2 und danach n gleich 1 und dann wieder 4, 01:17:32.860 --> 01:17:34.860 2, 1, 4, 2, 1 und so weiter haben. 01:17:34.860 --> 01:17:35.960 Das ist diese Vermutung. 01:17:36.820 --> 01:17:39.380 Man könnte das jetzt mal sagen, naja, ich höre die Schleife auf, wenn 01:17:39.380 --> 01:17:41.860 ich bei 1 ankomme, weil wenn ich bei 1 ankomme, dann weiß ich eben, 01:17:41.940 --> 01:17:43.980 dass es danach mit 4, 2, 1 immer weitergehen wird. 01:17:44.380 --> 01:17:46.600 Ich könnte jetzt so eine Schleife mal ausführen und das ist eben in 01:17:46.600 --> 01:17:50.700 der Mathematik noch ein ungelöstes Problem, ob es eine Zahl n gibt, 01:17:50.880 --> 01:17:54.980 die vielleicht doch nicht dazu führt, dass man am Ende zu dieser Folge 01:17:54.980 --> 01:17:56.120 4, 2, 1 immer kommt. 01:17:57.120 --> 01:17:59.440 Also das ist ein Beispiel, wo es sinnvoll ist, eine Wildschleife zu 01:17:59.440 --> 01:18:02.520 benutzen, weil ich eben nicht im Voraus abschätzen kann, wie sich 01:18:02.520 --> 01:18:05.820 diese Folge, die jetzt hier auch nochmal dargestellt ist mit XKCD, 01:18:06.380 --> 01:18:07.660 weiterentwickeln wird. 01:18:09.200 --> 01:18:16.340 Gut, soviel zu den While, Do-While und For-Schleifen. 01:18:16.840 --> 01:18:19.560 Auch hier, ähnlich wie beim If-Statement, besteht die Möglichkeit, 01:18:19.740 --> 01:18:20.800 Schleifen zu schachteln. 01:18:21.420 --> 01:18:24.860 Ich könnte mir jetzt also weiter überlegen, ich hätte gern ein 01:18:24.860 --> 01:18:31.580 Programm, das für zwei Integereingaben, p und m, dann p Zeilen auf der 01:18:31.580 --> 01:18:34.940 Konsole ausgibt, die jeweils die Zahlen von 1 bis m enthalten. 01:18:35.040 --> 01:18:36.740 Wir hatten eben nur so eine Zeile ausgegeben. 01:18:37.160 --> 01:18:39.780 Jetzt wollen wir also zum Beispiel, wenn wir p gleich 2 haben und m 01:18:39.780 --> 01:18:43.200 gleich 5, zwei Zeilen haben, die jeweils bis 5 durchnummeriert sind 01:18:43.200 --> 01:18:45.320 oder auch in anderen Zahlenkombinationen. 01:18:45.720 --> 01:18:48.600 Und für das kann ich Schleifen schachteln, so nennt es sich. 01:18:48.600 --> 01:18:52.660 Ich kann also hier wieder vorbereiten und dann eine For-Schleife 01:18:52.660 --> 01:18:57.800 machen, die erst mal i zählt von 1 bis p, also für die Zeilen 01:18:57.800 --> 01:19:01.980 zuständig ist und dann eine innere Schleife haben, die jeweils die 01:19:01.980 --> 01:19:05.060 Zahlen von 1 bis 5 jetzt in diesem Beispiel ausgibt, so wie wir es 01:19:05.060 --> 01:19:06.100 vorher schon gesehen haben. 01:19:07.540 --> 01:19:10.500 Und hier ist es jetzt eben so, ich beginne erst die äußere Schleife, 01:19:10.900 --> 01:19:13.860 führe dann die innere Schleife bis 5 wiederholend aus. 01:19:13.860 --> 01:19:18.240 Wenn die dann zu Ende gelaufen ist, gebe ich eine neue Zeile aus und 01:19:18.240 --> 01:19:21.680 fange dann wieder hier bei der äußeren Schleife an, führe dann wieder 01:19:21.680 --> 01:19:25.740 die innere Schleife 5 mal aus, gebe dann den Zeilenumbruch aus, 01:19:26.140 --> 01:19:28.860 springe dann wieder hier nach oben, führe die innere Schleife aus und 01:19:28.860 --> 01:19:32.060 so weiter bis ich dann, im guten Fall jetzt nur 2 mal, bis ich dann 01:19:32.060 --> 01:19:32.540 fertig bin. 01:19:35.770 --> 01:19:40.390 Genau, das ist nicht ganz so ersichtlich vielleicht, dieses Schachteln 01:19:40.390 --> 01:19:41.010 von Schleifen. 01:19:41.110 --> 01:19:44.430 Von daher gehen Sie ruhig nochmal so auf diese Folie oder decken Sie 01:19:44.430 --> 01:19:47.910 sich das ab und versuchen Sie das zu Hause selbst nochmal 01:19:47.910 --> 01:19:50.950 hinzuschreiben, diese geschachtelten Schleifen, weil da muss es im 01:19:50.950 --> 01:19:54.010 Kopf so ein bisschen Klick machen, bis man das verstanden hat, wie das 01:19:54.010 --> 01:19:54.450 funktioniert. 01:19:54.790 --> 01:19:55.890 Zumindest so meine Erfahrung. 01:19:57.390 --> 01:19:59.070 Gut, zwei Themen noch, bevor... 01:19:59.730 --> 01:20:02.010 Ich glaube jetzt den Hörsaal zu verlassen lohnt sich vielleicht nicht 01:20:02.010 --> 01:20:03.910 mehr, da können Sie die vier Minuten vielleicht auch noch eben warten. 01:20:04.510 --> 01:20:06.110 Zwei Themen habe ich nämlich noch, zwei kurze. 01:20:06.690 --> 01:20:12.770 Und zwar hatten wir ja noch die Schleifen-Modifikatoren, Break und 01:20:12.770 --> 01:20:13.310 Continue. 01:20:14.990 --> 01:20:17.330 Wir haben jetzt die Schleifen eben gesehen, es gibt eben noch zwei 01:20:17.330 --> 01:20:20.610 Möglichkeiten, diese normale Ausführung der Schleifen, wie ich sie 01:20:20.610 --> 01:20:23.190 gerade beschrieben habe, auch noch zu ändern zwischendurch. 01:20:23.570 --> 01:20:25.950 Was man zum Beispiel machen kann, ist Break zu benutzen. 01:20:26.330 --> 01:20:29.570 Das benutzt man, wenn man eine Schleife verlassen möchte, bevor man 01:20:29.570 --> 01:20:33.930 eigentlich normal sozusagen mit allen Schleifen-Durchläufen durch ist. 01:20:34.470 --> 01:20:37.270 Kann man zum Beispiel hier machen, nehmen wir mal an, wir wollen die 01:20:37.270 --> 01:20:41.330 Summe aller eingelesenen Zahlen bis zur Eingabe 0 berechnen. 01:20:41.330 --> 01:20:44.450 Kann ich also sagen, while true, bisschen unschön, aber gut. 01:20:44.450 --> 01:20:47.270 Soll i den Wert des nächsten Integers haben? 01:20:47.650 --> 01:20:50.490 Ich überprüfe, ob diese Zahl i 0 ist. 01:20:50.610 --> 01:20:52.210 Wenn ja, breche ich die Schleife ab. 01:20:52.310 --> 01:20:55.410 Wenn nicht, erhöhe ich die Summe um den Wert i und gehe dann hier 01:20:55.410 --> 01:20:57.130 wieder oben zur Bedingung, die es immer war. 01:20:57.270 --> 01:21:00.330 Ich lese den nächsten Wert ein, überprüfe wieder, ob der Wert 0 ist. 01:21:00.390 --> 01:21:01.750 Wenn nicht, bilde ich die Summe und so weiter. 01:21:02.210 --> 01:21:05.610 Und dann, wenn irgendwann mal eine Summe, eine 0 eingegeben wird, wird 01:21:05.610 --> 01:21:08.990 eben über das Break die Schleife verlassen und ich gebe die bis dahin 01:21:08.990 --> 01:21:10.770 berechnete Summe aus. 01:21:11.530 --> 01:21:15.070 Sieht ein bisschen unübersichtlich aus und ist tatsächlich auch was, 01:21:15.130 --> 01:21:16.690 was man nur sparsam verwenden sollte. 01:21:16.770 --> 01:21:18.710 An dieser Stelle ist es eigentlich nicht so schön, weil man sollte 01:21:18.710 --> 01:21:21.210 diese Bedingung lieber in das While hinein codieren. 01:21:22.370 --> 01:21:25.630 Aber manchmal hat man Fälle, wo man quasi mehrere Ausgangsbedingungen 01:21:26.490 --> 01:21:27.190 überprüfen möchte. 01:21:29.310 --> 01:21:30.390 Continue ist so ähnlich. 01:21:33.170 --> 01:21:34.050 Continue ist... 01:21:34.050 --> 01:21:36.950 richt allerdings nur die Ausführung der aktuellen Schleifen 01:21:36.950 --> 01:21:39.750 -Iterationen ab und springt dann direkt zur nächsten Iteration, also 01:21:39.750 --> 01:21:41.690 zur nächsten Überprüfung der Schleifenbedingungen. 01:21:42.110 --> 01:21:43.450 Man kann zum Beispiel sowas hier schreiben. 01:21:43.950 --> 01:21:44.910 Jetzt das Gleiche wie eben. 01:21:45.050 --> 01:21:46.110 Ich überprüfe auf 0. 01:21:48.730 --> 01:21:50.450 Wenn der Wert... 01:21:50.450 --> 01:21:52.330 Also hier will ich zum Beispiel die Anzahl der Einsen zählen. 01:21:52.850 --> 01:21:56.830 Wenn jetzt mein Eingabewert von Scanner nicht gleich 1 ist, dann soll 01:21:56.830 --> 01:21:57.630 ich hier weitermachen. 01:21:57.710 --> 01:22:01.230 Das heißt, ich springe von diesem Continue wieder hin zur nächsten 01:22:01.230 --> 01:22:05.610 Überprüfung der Bedingung und sonst zähle ich die Anzahl der Einsen 01:22:05.610 --> 01:22:06.570 jetzt mal in diesem Beispiel. 01:22:07.210 --> 01:22:10.290 Also damit kann ich auch modifizieren und quasi hier aus der Mitte der 01:22:10.290 --> 01:22:13.810 Schleifenausführung herausspringen wieder zur Überprüfung der 01:22:13.810 --> 01:22:14.190 Bedingungen. 01:22:14.210 --> 01:22:15.850 Sollte man auch sparsam einsetzen. 01:22:17.330 --> 01:22:19.410 So, wir hätten jetzt eigentlich noch, aber das schaffen wir jetzt 01:22:19.410 --> 01:22:25.790 nicht mehr, eine kleine Übungsaufgabe, welche Art, eine Schleife zu 01:22:25.790 --> 01:22:27.370 schreiben, am schönsten ist. 01:22:29.010 --> 01:22:30.690 Es gibt verschiedene Für und Widers. 01:22:30.990 --> 01:22:32.710 Müssen wir mal gucken, ob wir das beim nächsten Mal noch machen. 01:22:33.030 --> 01:22:36.210 Oder ansonsten würde ich Sie bitten, sich das noch mal zu Hause 01:22:36.210 --> 01:22:36.870 anzuschauen. 01:22:36.870 --> 01:22:39.610 Wir haben eben verschiedene Varianten, wie ich Schleifen schreiben 01:22:39.610 --> 01:22:42.690 kann und die Frage, welche von denen am schönsten ist, ein bisschen 01:22:42.690 --> 01:22:43.210 auch danach. 01:22:43.270 --> 01:22:43.890 Wir sind noch nicht fertig. 01:22:45.390 --> 01:22:46.730 Es ist noch 29. 01:22:47.230 --> 01:22:48.290 Ein paar Folien habe ich noch. 01:22:48.390 --> 01:22:50.930 Ich springe eben über diese Schleifenorganisationsfolien hinweg. 01:22:51.930 --> 01:22:53.530 Aber die Zusammenfassung fehlt ja noch. 01:22:53.930 --> 01:22:56.170 Damit Sie jetzt noch mal eben überlegen können, was haben Sie jetzt 01:22:56.170 --> 01:22:56.710 heute gelernt. 01:22:56.890 --> 01:22:57.890 Ich hoffe, Sie haben was gelernt. 01:22:58.770 --> 01:23:01.790 Wir haben zum einen über Ausdrücke und Anweisungen gesprochen. 01:23:02.690 --> 01:23:04.030 Ausdrücke berechnen einen Wert. 01:23:04.830 --> 01:23:07.910 Anweisungen sind die Sätze der Programmiersprache und ändern den 01:23:07.910 --> 01:23:09.350 Zustand unseres Programms. 01:23:09.930 --> 01:23:12.230 Wir haben kurz über Eingaben gesprochen mit der Klasse Scanner. 01:23:13.470 --> 01:23:16.850 Und etwas ganz, ganz Essentielles in der Programmierung. 01:23:17.430 --> 01:23:19.890 Das lohnt sich jetzt wirklich, das ein bisschen nachzuarbeiten, wenn 01:23:19.890 --> 01:23:20.910 Sie es noch nicht verstanden haben. 01:23:21.450 --> 01:23:24.830 Nämlich einerseits die Fallunterscheidung mit If und Switch und die 01:23:24.830 --> 01:23:27.630 Schleifen mit While, Do, While und For. 01:23:28.190 --> 01:23:31.170 Und damit können Sie dann das machen, was Turing gesagt hat, nämlich 01:23:31.170 --> 01:23:35.050 alle Bereiche der Menschheit umsetzen. 01:23:35.150 --> 01:23:37.390 Alles, was Sie sich erträumen können, als mögliche Berechnungen 01:23:37.390 --> 01:23:39.870 sozusagen, implementieren in Ihrem Java-Code. 01:23:40.250 --> 01:23:41.370 Okay, das reicht für heute. 01:23:41.570 --> 01:23:43.510 Wir sehen uns nächste Woche und viel Spaß bei den Übungen.