public class BedingungenSchleifen { public static void main(String[] args) { // Schleifen: // Werden genutzt, um einen Teil des Programms, also einen oder mehrere Befehle // mehrfach auszuführen. // Es gibt verschiedene Arten von Schleifen, welche für verschiedene Zwecke sinnvoll sind. // while-Schleife // Diese Schleifenform wird verwendet, wenn nicht bekannt ist, wie oft die Schleife durchlaufen wird. // Es ist also nur eine Bedingung bekannt, in welchem Fall die Schleife ausgeführt werden soll. Ist diese // Bedingung nicht mehr erfüllt, wird abgebrochen. // In diesem Beispiel wird die Schleife so oft wiederholt, bis der Zufallszahlen Generator eine Zahl größer // als 0.9 ausgibt. Es ist nicht bekannt, ob dafür 1 Schleifendurchgang oder 100 benötigt werden. double i = 0; while (i < 0.9) { i = Math.random(); // Erstellt Zahlen zwischen 0 und 1 System.out.println(i); } // ------------------------------------------------- // Zählschleife: // Diese Art von Schleifen wird verwendet, wenn die Anzahl der Durchgänge bekannt ist. // Bsp.: Bei der Auslosung von Lottozahlen ist bekannt, dass 6 + 1 Zahlen generiert werden müssen. // Eine Zählschleife wird in Java for-Schleife genannt und sieht wie folgt aus: for (int durchlauf = 0; durchlauf < 7; durchlauf++) { int zahl = (int)(Math.random() * 49 + 1); // Ganzzahlen 1-49 generieren System.out.println("Durchlauf: " + (durchlauf + 1) + " Zahl: " + zahl); } // Erklärung der Syntax: In der for-Schleife gibt es 3 Parameter, welche durch Semikola getrennt sind. // 1. Parameter: Initialisierung der Zählvariable (int durchlauf = 0) // 2. Parameter: Bedingung wie lange die Schleife laufen soll (durchlauf < 7) // 3. Parameter: Schrittweite: durchlauf++, also jedes mal um 1 hochzählen. Alternativen: durchlauf-- oder // durchlauf += 2 // Es gibt noch eine foreach-Schleife. Diese wird erst später im Arrays Kapitel behandelt. // -------------------------------------------------- // Bedingungen: // Mit if-Anweisungen kann man basierend auf Bedingungen Code ausführen. int zehn = 10; // Folgend zwei Beispiele einer einfachen if-Anweisung: if (zehn == 10) { System.out.println("Dieser Code wird ausgeführt."); } // Da die Bedingung nicht erfüllt ist, wird der Code in den geschweiften Klammern nicht ausgeführt. if (zehn != 10) { System.out.println("Dieser Code wird nicht ausgeführt."); } // Oft soll bei wahr/falsch der Bedingung jeweils Code ausgeführt werden. Damit man nicht zwei einzelne if-Anweisungen // schreiben muss, gibt es das if-else-Konstrukt: if (zehn == 10) { System.out.println("Variable hat den Wert 10."); } else { System.out.println("Variable hat nicht den Wert 10."); } // Sollen jetzt mehrere Abfragen ineinander geschachtelt werden, gibt es den else-if-Befehl, um tiefere Schachtelung zu vermeiden. // Bsp. was mit tieferer Schachtelung gemeint ist: Bei den Werten 10, 11, 12 (und der Rest) sollen unterschiedliche // Ausgaben auf dem Bildschirm erscheinen. // Methode mit Schachtelung: if (zehn == 10) { System.out.println("Die Bedingung ist wahr. Der Wert ist 10."); } else { // Erste Schachtelung if (zehn == 11) { System.out.println("Fast wahr. Eins daneben. Der Wert ist 11."); } else { // Zweite Schachtelung if (zehn == 12) { System.out.println("Second first try. Der Wert ist 12."); } else { // Allgemeiner Fall System.out.println("Der Wert ist irgendwas anderes... Wert: " + zehn); } } } // Methode mit else-if Konstrukt: if (zehn == 10) { System.out.println("Die Bedingung ist wahr. Der Wert ist 10."); } else if (zehn == 11) { System.out.println("Fast wahr. Eins daneben. Der Wert ist 11."); } else if (zehn == 12) { System.out.println("Second first try. Der Wert ist 12."); } else { // Allgemeiner Fall System.out.println("Der Wert ist irgendwas anderes... Wert: " + zehn); } // Sollen in einem Programm nur Fälle unterschieden werden, wie im letzten Beispiel, dann kann auch ein // switch-case-Konstrukt verwendet werden. Switch kann nur Vergleiche (bspw. a == 2) prüfen und keine Bedingungen, // also bspw. a > 5. // Die Switch Anweisung hat sich über die Java Versionen stark verändert. In anderen Programmiersprachen lassen // sich nur Integer miteinander vergleichen. Ab Java 8 wurden hingegen auch Strings und Enums (mehr dazu später) // hinzugefügt. In neueren Versionen wurde der Switch weiter angepasst. Dazu gibt es in diesem Kapitel noch einen // kleinen Exkurs, welcher aber für den Anfang nicht relevant sein dürfte. // Klassischer Switch: // Einem switch wird eine Variable übergeben, welche dann auf Fälle (case) geprüft werden. // Mit der Anweisung break; wird der Switch verlassen. Dies ist wichtig, da ab einem case-label ausgeführt wird. // Das bedeutet: ist ein Fall eingetroffen, wird ab dort alles ausgeführt. Dieses Verfahren erscheint wahrscheinlich // erstmal sinnlos, hat jedoch seinen Sinn, falls mehrere cases den gleichen Code ausführen sollen. // Beispiel von vorher: switch (zehn) { case 10: System.out.println("Die Bedingung ist wahr. Der Wert ist 10."); break; case 11: System.out.println("Fast wahr. Eins daneben. Der Wert ist 11."); break; case 12: System.out.println("Second first try. Der Wert ist 12."); break; default: // Allgemeiner Fall heißt default-case System.out.println("Der Wert ist irgendwas anderes... Wert: " + zehn); break; // Ist nicht nötig } // Möchte man z.B. die gleiche Ausgabe für die Werte 9, 10 und 11, dann wird das break; weggelassen und der Code // ab dem entsprechenden case ausgeführt. Bsp.: switch (zehn) { case 9: case 10: case 11: System.out.println("Wir sind im Fall 9-11"); break; case 12: System.out.println("Hier sind wir im Fall 12"); break; default: System.out.println("Default case."); } // Probier einfach mal aus, was passieren würde, wenn die break; Befehle weg sind. // Seit Java 8 geht das auch mit Strings, also hier ein kleines Beispiel: String wochentag = "di"; switch (wochentag) { case "mo": case "di": case "mi": case "do": case "fr": System.out.println("Ganz normaler Wochentag"); break; case "sa": case "so": System.out.println("Wochenende"); break; default: System.out.println("Komischer Wochentag..."); } // Das waren die wichtigen Dinge. Nun folgen nur noch ein paar interessante Dinge, die wahrscheinlich erst später // relevant werden könnten. // ---------------------------------------------------------------------- // Switch Exkurs: // In Java 12 wurde der Switch Block erneut überarbeitet und kann nun einen Wert zurückgeben. // Zudem können nun mehrere Labels in einem case vorkommen. Der Rückgabewert kann entweder mittels yield oder // Pfeil -> angegeben werden (in Java 13 wurde break als Rückgabe mit dem Wort yield ersetzt). // Das Beispiel von vorher mit Rückgabe, ob der eingegebene String ein Wochenendtag ist oder nicht. // Funktioniert nur mit min. Java 12 boolean isWeekend = switch (wochentag) { case "mo", "di", "mi", "do", "fr": yield false; case "sa", "so": yield true; default: yield false; }; System.out.println("Wochentag: " + wochentag + " ist am Wochenende: " + isWeekend); // Oder mit Pfeil (yield und Pfeil dürfen nicht gemischt verwendet werden) boolean isSecondWeekend = switch (wochentag) { case "mo", "di", "mi", "do", "fr" -> false; case "sa", "so" -> true; default -> false; }; System.out.println("Wochentag: " + wochentag + " ist am Wochenende: " + isSecondWeekend); // In Java 17 wurde Pattern Matching in switches hinzugefügt. Dies ist allerdings nur ein Preview Feature, // bedeutet man muss es explizit aktivieren und es wird eventuell in späteren Version nicht oder nicht in dieser // Form übernommen. } }