Update Kapitel 2

BedingungenSchleifen.java

@@ -0,0 +1,50 @@
+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:
+    }
+}

PrimitiveDatentypen.java

@@ -94,6 +94,39 @@ public class PrimitiveDatentypen {
 
         double division = ganzzahlAddition / (double)ganzzahlMultiplikation;
         System.out.println("Ergebnis Division: " + division);
+
+
+        // Kurzschreibweisen:
+        // Will man eine Rechenoperation auf eine Variable ausführen und direkt wieder in diese hinein schreiben,
+        // kann man das so schreiben:
+        int pluseins = 0;
+        pluseins = pluseins + 1;
+        // Damit wurde die Variable pluseins um 1 erhöht.
+
+        // Um nicht den Variablennamen zweimal schreiben zu müssen, kann man auch die Kurzform nutzen:
+
+        pluseins += 1;
+        // Dies geht auch mit anderen Operatoren z.B.:
+        // += Addition
+        // -= Subtraktion
+        // *= Multiplikation
+        // /= Division
+
+        // Für Addition und Subtraktion gibt es noch eine weitere Kurzform, da plus/minus 1 besonders oft verwendet wird:
+        pluseins++; // Um die Variable um 1 zu erhöhen
+        pluseins--; // Um die Variable um 1 zu verkleinern
+
+
+        // ----------------------------------------------------------
+        // Zeichenketten: Können in Java ganz einfach mit einem + verkettet werden.
+        // Bspw.:
+        String str1 = "Ananas";
+        String str2 = "Cocobello";
+
+        String zusammengesetzt = str1 + " " + str2;
+        System.out.println(zusammengesetzt);
+
+
     }
 
 }

README.md

@@ -2,3 +2,11 @@
 
 ## Kapitel
 * Primitive Datentypen (Datei: PrimitiveDatentypen.java)
+* Bedingungen und Schleifen (Datei: BedingungenSchleifen.java)
+* Methoden
+* Arrays
+* Objekte
+* Vererbung
+* Polymorphismus
+* Interfaces
+* Nebenläufigkeit (Concurrency)