# Schleifen / Loops

Schleifen sind grundlegende Kontrollstrukturen in der
Programmierung, die es ermöglichen,

- einen Codeblock **wiederholt** auszuführen,
- solange eine bestimmte **Bedingung** erfüllt ist.

Sie sind besonders nützlich, um repetitive Aufgaben zu automatisieren
und den Code effizienter und kompakter zu gestalten.

Es gibt verschiedene Arten von Schleifen, die in fast jeder
Programmiersprache vorkommen: 
- **for-Schleife**:
  - Eine Schleife, die verwendet wird, wenn die Anzahl der
    Wiederholungen bekannt ist


- **while-Schleife**:
  - Sie wird verwendet, wenn die Anzahl der Wiederholungen nicht bekannt
    ist.
  - Sie endet, wenn eine bestimmte Bedingung nicht mehr wahr ist.


- **do-while-Schleife**:
  - Sie ähnelt der **while-Schleife** - nur mit dem Unterschied, dass
    sie in jedem Fall **einmal** ausgeführt wird und erst anschließend
    die Bedingung geprüft wird.
  - Du wirst sehen, auch dieses Verhalten ist immer wieder gefragt beim
    Programmieren.


## for-Schleife

Eine `for`-Loop ist eine der grundlegendsten und am häufigsten
verwendeten Kontrollstrukturen in Java.

Sie ermöglicht es, eine Anweisung oder einen Block von Anweisungen
wiederholt auszuführen, solange eine bestimmte Bedingung erfüllt ist.

Die Syntax einer `for`-Loops in Java sieht folgendermaßen aus: 
``` java
for (Initialisierung; Bedingung; Update) {
    // Codeblock, der wiederholt ausgeführt wird
}
```

Du siehst an der Farbe des Wortes, dass das `for` ein
Java-Schlüsselwort ist. Es wird gefolgt von einem Block in runden
Klammern: `(initalization; condition; update)`. Was bedeutet das?


- **Initialisierung**: Wir brauchen eine Zählvariable, die die Anzahl
  der Durchläufe zählt. Meist setzten wir sie beim Start auf 0 - aber
  nagel mich nicht fest darauf! Es gibt auch Fälle, wo wir andere
  Startwerte brauchen


- **Bedingung**: Hier legen wir fest, wie lange die Schleife ausgeführt
  wird. Meist haben wir eine Menge von Elementen, deren Anzahl wir
  kennen und dann lassen wir die Schleife solange laufen, bis auch das
  letzte Element behandelt wurde


- **Update**: Die Zählvariable bekommt einen neuen Wert. Wie dieser
  berechnet wird, steht in diesem Block

Hier nun ein konkretes Beispiel:

``` java
for (int i = 0; i < 10; i++) {
    System.out.println("Die aktuelle Zahl ist: " + i);
}
```

Kannst du erkennen, was die Schleife macht?

1.  **Initialisierung**: Wir deklarieren eine Variable `i` vom Datentyp
    `int` und weisen ihr den Startwert `0` zu.
2.  **Bedingung**: Wir sagen, dass die Schleife so lange laufen soll,
    wie diese Variable `i` kleiner als 10 ist. Aber wieso steht das denn
    infrage? 0 ist doch kleiner 10!? Ja, aber die Variable `i` wird
    aufgrund des Updates immer größer!
3.  **Update**: Die Zählvariable bekommt einen neuen Wert. In diesem
    Fall wird durch das `i+++` die Variable `i` in jedem Durchlauf um 1
    erhöht.

### Deklaration und Initalisierung außerhalb des Schleifenkopfes
Nicht immer wird die Zählvariable im Schleifenkopf deklariert. Stell dir ein Programm vor, wo die Anzahl der Schleifendurchläufe vom **Ergebnis einer vorherigen Berechnung abhängig** ist:

```java
int anzahlKinder = 3;
int anzahlErwachsene = 12;
int anzahlPersonen = anzahlKinder + anzahlErwachsene;
for (; anzahlPersonen < 10; anzahlPersonen++) {
    System.out.println(anzahlPersonen);
}
```
**Hier wird im Schleifenkopf ganz darauf verzichtet, eine Zählvariable zu deklarieren und initalisieren.  
Es wird einfach die Variable `anzahlPersonen` verwendet, die außerhalb der Schleife deklariert und berechnet wurde.**

## while-Schleife

`while`-Loops sind wie bereits erwähnt, flexibler bei einer
unbekannten Zahl von Iterationen. Das kann passieren, wenn eine Menge
von Einträgen zu durchlaufen sind, wir aber nicht wissen, wie viele
genau das sein werden. 

Anders als bei der `for`-Loop wird diesmal nähmlich keine Zählvariable deklariert und
initialisiert. Falls wir eine solche Variable haben wollen, müsste diese
von außen beigesteuert werden. 


Eine `while`-Loop checkt vielmehr oftmals, ob bestimmte **Bedingungen**
noch wahr sind, ob sich beispielsweise **Zustände** geändert haben, oder
nicht.


``` java
        Scanner scanner = new Scanner(System.in);
        String input = "";

        while (input.equals("exit") == false) {
            System.out.println("Gib 'exit' ein, um die Schleife zu beenden:");
            input = scanner.nextLine();
        }

        scanner.close();
```


``` java
        int i = 0; // Initialisierung der Variablen
        while (i < 5) { // Bedingung prüfen
            System.out.println(i); // Schleifen-Körper
            i++; // Variablen aktualisieren
        }
```


## do-while-Schleife

Die **do-while**-Schleife ist eine Kontrollstruktur in Java, die sich perfekt für Situationen eignet, in denen eine Aktion **mindestens einmal** ausgeführt werden soll, bevor eine Bedingung überprüft wird.  

**Merkmale der do-while-Schleife**

- Der **Schleifenrumpf** wird immer **mindestens einmal** ausgeführt.
- Erst **nach der ersten Iteration** wird die Bedingung überprüft.
- Wenn die Bedingung **wahr (true)** bleibt, wird die Schleife erneut durchlaufen.
- Falls die Bedingung **falsch (false)** ist, endet die Schleife.

### Syntax:
```java
do {
    // Code, der mindestens einmal ausgeführt wird
} while (Bedingung);
```


### Beispiel Würfelspiel

Stell dir ein Würfelspiel vor. Es soll so lange gewürfelt werden, bis eine 6 gefallen ist.

Das ist der klassische Use-Case für eine `do-while`: 
- Mindestens einmal muss eine Aktion ausgeführt werden (gewürfelt)
- **Danach** wird die Aktion ausgewertet (wurde eine 6 gewürfelt)

```java
import java.util.Random;

public class WuerfelSpiel {
    public static void main(String[] args) {
        Random random = new Random();
        int wurf;

        System.out.println("Würfel wird geworfen...");

        do {
            wurf = random.nextInt(6) + 1; // Zufallszahl zwischen 1 und 6
            System.out.println("Geworfen: " + wurf);
        } while (wurf != 6);

        System.out.println("Eine 6 wurde geworfen! Spiel beendet.");
    }
}
```