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.

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:

for (Initialisierung; Bedingung; Update) {
    // Codeblock, der wiederholt ausgeführt wird
}

• 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:

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

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.

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.

        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();

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

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.

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

do {
    // Code, der mindestens einmal ausgeführt wird
} while (Bedingung);

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)

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.");
    }
}