JavaTutorial/BedingungenSchleifen.java

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.
    }
}