Update PrimitiveDatentypen and BedingungenSchleifen

BedingungenSchleifen.java

@@ -46,5 +46,161 @@ public class BedingungenSchleifen {
 
         // --------------------------------------------------
         // 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.
     }
 }

PrimitiveDatentypen.java

@@ -126,6 +126,40 @@ public class PrimitiveDatentypen {
         String zusammengesetzt = str1 + " " + str2;
         System.out.println(zusammengesetzt);
 
+        // ------------------------------------------------------------
+        // Logik mit Booleans.
+        // Wird vor allem im nächsten Thema, wenn es um Bedingungen und Schleifen geht relevant.
+        // Alle Bedingungen in Java müssen auf einen Wahrheitswert ausgewertet werden können.
+        // Das heißt, man muss immer eine Bedingung finden, die mit Ja/Nein beantwortbar ist.
+        // Bspw.: 5 < 10 ist wahr, 5 > 10 ist falsch usw.
+
+        // Für Vergleiche gibt es folgende Zeichen:
+        // == Auf Gleichheit prüfen (ein einzelnes "=" ist in Java eine Zuweisung)
+        // != Ungleich
+        // > Echt größer
+        // >= Größer gleich
+        // < Echt kleiner
+        // <= Kleiner gleich
+
+        // Beispiele:
+        boolean gleichheit = 4 == 4; // Hier sieht man den Unterschied zwischen Vergleich und Zuweisung nochmal
+        System.out.println("Gleichheit: " + gleichheit);
+
+        boolean groesser = 4 > 5;
+        System.out.println("Ist 4 > 5? " + groesser);
+
+        // Booleans können mit einem ! negiert werden:
+        boolean nichtGroesser = !groesser;
+        System.out.println("Das Gegenteil von 4 > 5: " + nichtGroesser);
+
+        // Strings können in Java nicht mit == verglichen werden,
+        // da hiermit nur die Speicheradressen verglichen werden. Das sagt jedoch nichts über den Inhalt, dessen Gleichheit
+        // uns normalerweise interessiert, aus.
+        // Deshalb gibt es bei Strings den Operator .equals().
+        // Bsp.:
+
+        boolean stringGleichheit = str1.equals(str2);
+        System.out.println("Sind die Strings 1 und 2 gleich? " + stringGleichheit);
 
     }
 

README.md

@@ -6,6 +6,7 @@
 * Methoden
 * Arrays
 * Objekte
+* Datenstrukturen (Enums, Dynamische Arrays, Maps)
 * Vererbung
 * Polymorphismus
 * Interfaces