Schleifen.

Eine Schleife wiederholt einen Codeblock mehrfach: solange eine Bedingung gilt, solange noch Elemente in einem Iterable vorhanden sind, oder bis der Ablauf durch break vorzeitig endet. Ohne Schleifen müsstest du jede Wiederholung einzeln hinschreiben, was bei 1000 Iterationen schwerer wartbar und fehleranfälliger wird. Du lernst hier die drei Schleifentypen for, while und do-while (Letzteres existiert nur in Java, Python simuliert das Muster mit while True + break), wann du welchen einsetzt und wie die Kontrollanweisungen break und continue den Ablauf beeinflussen. Außerdem die drei klassischen Klausur-Fallen: Off-by-one (< vs <=), Endlosschleifen durch falsche Zähler-Richtung, und verschachtelte Schleifen: in Java musst du unterschiedliche Zählernamen wie i und j verwenden (Compile-Error wenn die äußere Variable im inneren Block noch im Scope ist), in Python überschreibt ein wiederverwendeter Name nach der inneren Schleife den äußeren Wert (Python kennt nur Scope auf Funktions- und Klassen-Ebene, kein Block-Scope für for/if/while, beide Schleifen leben im selben Funktions-Scope und teilen denselben Namen). Faustregel: bei verschachtelten Loops immer klare Namen wie row/col oder i/j.

Schleifenarten:

• for-Schleife: in Python typisch zum Iterieren über Elemente (Listen, Strings, Ranges, Dateien, alles, woraus Python nacheinander Elemente liefern kann). Du brauchst keinen expliziten Index, Python gibt dir direkt das Element. In Java gibt es zwei Varianten: den klassischen Zähler-Stil for (int i = 0; i < n; i++) (du arbeitest mit dem Index i) und das enhanced-for (auch "for-each") for (String s : liste) (du arbeitest direkt mit dem Element). Faustregel: Wenn du den Index brauchst, nimm die klassische for-Schleife; wenn du nur die Elemente brauchst, nimm for-each.
• while-Schleife: prüft die Bedingung vor jedem Durchlauf. Praktisch wenn du das Ende erst zur Laufzeit erfährst (z. B. "solange User noch Eingaben macht"). Man kann mit while auch zählen, aber bei klarer Zählstruktur ist for meist lesbarer.
• do-while (nur Java): wie while, aber prüft die Bedingung erst nach dem ersten Durchlauf, der Körper läuft also garantiert mindestens einmal. Python hat keine native do-while-Schleife, man simuliert das Muster meist mit while True und break.

Kontrollanweisungen innerhalb von Schleifen (keine Schleifenarten):

• break: verlässt die Schleife sofort
• continue: springt zur nächsten Iteration

In Klausuren wirst du oft gefragt: welche Ausgabe produziert diese Schleife? oder wie oft wird die Schleife durchlaufen?. Pro Iteration auf Papier den Zustand der Variablen aufschreiben ist der sicherste Weg, Off-by-one-Fehler zu vermeiden.

Die for-Schleife

Eine klassische for-Schleife in Java besteht aus drei Teilen, getrennt durch Semikolons:

for (int i = 0; i < 5; i++) {
  System.out.println("Runde " + i);
}

for i in range(5):
    print(f"Runde {i}")

Der Computer führt diese Schritte aus:

1. int i = 0 einmal am Anfang
2. i < 5 prüfen, falls wahr weitermachen, sonst Schleife beenden
3. Schleifenkörper ausführen (in dem Fall: println)
4. i++ ausführen (i um 1 erhöhen)
5. Zurück zu Schritt 2

Das Ergebnis: die Werte 0, 1, 2, 3, 4 werden ausgegeben. Fünf Iterationen, nicht sechs. Die Schleife endet sobald i = 5 ist, weil 5 < 5 falsch ist.

Schritt-für-Schritt-Trace

So sieht der Variablenzustand pro Iteration aus, exakt was du auf Papier mitschreiben würdest:

Iteration   i (vor Check)   i < 5   Ausgabe   nach i++
─────────────────────────────────────────────────────────
   1             0          true     "0"          1
   2             1          true     "1"          2
   3             2          true     "2"          3
   4             3          true     "3"          4
   5             4          true     "4"          5
   -             5          false    -            -

Die Trace-Tabelle ist die zuverlässigste Methode für Klausur-Tracing-Aufgaben: eine Spalte pro Variable, eine Zeile pro Iteration, dann sieht man Off-by-one-Fehler sofort.

Die for-each / Enhanced-for (Java)

Wenn du nicht den Index brauchst sondern die Elemente selbst, ist die enhanced-for-Variante deutlich lesbarer:

String[] namen = {"Anna", "Ben", "Cleo"};

// Klassisch mit Index
for (int i = 0; i < namen.length; i++) {
    System.out.println(namen[i]);
}

// Enhanced-for (for-each), gleicher Output
for (String name : namen) {
    System.out.println(name);
}

Funktioniert für Arrays und alles was Iterable<T> implementiert (List, Set, etc.). Was du nicht machen kannst: das Element via name = "anders" im Array überschreiben, weil name nur eine Kopie der Referenz ist. Brauchst du den Index zur Mutation, klassisches for nutzen.

Vorsicht bei mutable Objekten: bei for (Person p : personen) ist p nur eine Referenz-Kopie. Du kannst das Objekt mutieren (p.setName("...") greift), aber du kannst nicht die Stelle im Array umbiegen (p = new Person(...) macht nichts am Array). Bei immutable Typen wie String oder Integer kannst du das Objekt selbst nicht mutieren. Eine Zuweisung an die for-each-Variable ist zwar syntaktisch möglich, ersetzt aber nicht das Element im Array oder in der Collection.

Die while-Schleife

while prüft die Bedingung vor jedem Durchlauf. Wenn die Bedingung beim ersten Check schon false ist, läuft der Körper null Mal. Im einfachsten Fall lässt sich while als "for-Ersatz mit Handarbeit" lesen, du musst Zähler-Init und Inkrement selbst schreiben:

int i = 0;
while (i < 5) {
    System.out.println("Runde " + i);
    i++;
}

i = 0
while i < 5:
    print(f"Runde {i}")
    i += 1

Trace:
Iteration   i (vor Check)   i < 5   Ausgabe   nach i++
─────────────────────────────────────────────────────────
   1             0          true    "Runde 0"    1
   2             1          true    "Runde 1"    2
   3             2          true    "Runde 2"    3
   4             3          true    "Runde 3"    4
   5             4          true    "Runde 4"    5
   -             5          false   -            -

Echter Use-Case für while (wo for unpraktisch wäre): Eingabe-Loops. Du weißt vorher nicht wie oft, sondern liest bis Abbruch-Wert:

eingabe = input("Zahl (oder 'q' zum Beenden): ")
while eingabe != "q":
    print(f"Du hast {eingabe} eingegeben.")
    eingabe = input("Zahl (oder 'q' zum Beenden): ")

Die do-while-Schleife (nur Java)

do { ... } while (cond); prüft die Bedingung nach dem Körper, der Körper läuft also garantiert mindestens einmal. Klausur-Klassiker:

int versuch = 0;
do {
    System.out.println("Versuch " + versuch);
    versuch++;
} while (versuch < 3);
// Ausgabe: Versuch 0, Versuch 1, Versuch 2

Trace:
Iteration   Körper läuft   versuch (vor)   versuch++   Check (versuch < 3)
──────────────────────────────────────────────────────────────────────────
   1        "Versuch 0"          0              1       true
   2        "Versuch 1"          1              2       true
   3        "Versuch 2"          2              3       false -> Schleife endet

Selbst wenn die Bedingung von Anfang an false ist, läuft der Körper einmal:

int x = 100;
do {
    System.out.println("Hallo");  // wird AUSGEGEBEN, obwohl x < 5 false ist
} while (x < 5);
// Ausgabe: Hallo (genau einmal)

Python hat das nicht direkt, man baut das Muster nach:

while True:
    eingabe = input("Passwort: ")
    if eingabe == "geheim":
        break

break und continue im Detail

Beide Anweisungen unterbrechen den normalen Schleifen-Ablauf, aber unterschiedlich:

// break: Schleife komplett verlassen
for (int i = 0; i < 10; i++) {
    if (i == 5) break;
    System.out.print(i + " ");
}
// Ausgabe: 0 1 2 3 4

// continue: aktuelle Iteration überspringen, weiter mit der nächsten
for (int i = 0; i < 10; i++) {
    if (i % 2 == 0) continue;
    System.out.print(i + " ");
}
// Ausgabe: 1 3 5 7 9

Trace break-Beispiel:
Iter   i (vor)   i == 5?   Aktion         Ausgabe
─────────────────────────────────────────────────
  1       0      false     print + i++    "0 "
  2       1      false     print + i++    "1 "
  3       2      false     print + i++    "2 "
  4       3      false     print + i++    "3 "
  5       4      false     print + i++    "4 "
  6       5      true      break          Schleife endet

Trace continue-Beispiel (i=0..5):
Iter   i (vor)   i%2==0?   Aktion         Ausgabe
─────────────────────────────────────────────────
  1       0      true      continue       -
  2       1      false     print + i++    "1 "
  3       2      true      continue       -
  4       3      false     print + i++    "3 "
  5       4      true      continue       -
  6       5      false     print + i++    "5 "

Vorsicht in while-Schleifen: nach continue wird die Bedingung wieder geprüft, der Schleifenkörper aber von vorne. Wenn du den Zähler nicht VOR dem continue erhöhst, kann es zur Endlosschleife kommen:

int i = 0;
while (i < 10) {
    if (i == 5) continue;   // ENDLOSSCHLEIFE, i bleibt bei 5
    System.out.println(i);
    i++;
}

In dieser klassischen Java-for-Schleife mit i++ im Header passiert das nicht, weil continue zuerst den Update-Ausdruck ausführt. Fehlt der Update-Ausdruck (for (int i = 0; i < n;)), kann auch eine for-Schleife endlos werden.

Schleifeninvariante

Korrektheits-Klausuren fragen oft: "Warum macht diese Schleife was sie soll?" Die Antwort ist eine Schleifeninvariante: eine Aussage, die in jedem Iterationszyklus wahr bleibt.

Wichtige Abgrenzung: Nicht jede Variable ist eine Invariante. Eine Invariante ist eine Aussage über Variablen, die vor jedem Schleifendurchlauf gilt. Sie ist kein Zustand in einem Moment, sondern ein logisches Statement das die ganze Schleife durchhält.

Drei Schritte zum Beweis:

1. Initialisierung, Invariante gilt VOR dem ersten Durchlauf.
2. Erhaltung, wenn die Invariante vor dem Körper gilt, gilt sie auch nach i++ wieder.
3. Terminierung, wenn die Schleife endet, folgt aus Invariante + endgültiger Bedingung das gewünschte Ergebnis.

Konkret am Maximum-Suchen:

int[] zahlen = {3, 7, 2, 8, 5};
int max = zahlen[0];
for (int i = 1; i < zahlen.length; i++) {
    if (zahlen[i] > max) {
        max = zahlen[i];
    }
}

Invariante: "Vor jedem Schleifenkopf gilt: max ist das Maximum von zahlen[0..i-1]."

Die Invariante ist der rote Faden der die Schleife korrekt macht.

Häufige Fehler

• Off-by-one: falsche Wahl von < vs. <=. Je nach Zielbereich fehlt dadurch eine Iteration oder läuft eine zu viel. <= ist nicht generell falsch (z. B. "Ausgabe 1 bis 10 in Java" braucht i <= 10).
• Unendliche Schleife: Zähler wird in die falsche Richtung verändert oder gar nicht, die Bedingung bleibt immer wahr und das Programm hängt.
• Zähler nicht initialisiert auf einen sinnvollen Wert.
• continue ohne Zähler-Inkrement in while-Schleifen (siehe oben).
• Nested Loops mit gleichem Zählernamen, in Java Compile-Error, in Python stiller Bug:

// Java: Compile-Error im inneren for
for (int i = 0; i < 3; i++) {
    for (int i = 0; i < 5; i++) {   // ERROR: i is already defined
        // ...
    }
}

# Python: kein Block-Scope -> inneres for überschreibt i nach der inneren Schleife
for i in range(3):
    for i in range(5):
        pass
    print(i)   # Ausgabe: 4, 4, 4 (NICHT 0, 1, 2!), i wurde durch innere Schleife überschrieben

Faustregel: bei verschachtelten Loops klare unterschiedliche Namen (i/j oder row/col) verwenden, dann gibt's diesen Bug nie.

Schleife in Bewegung

Range-Slider-Demo: du änderst Start- und Endwert über die Eingabefelder, klickst auf Schritt für eine manuelle Iteration oder Auto um zuzusehen wie die Schleife durchläuft. Drei Modi rechts oben: Frei spielen (Parameter beliebig ändern), Vorhersagen (Anzahl Iterationen vor dem Lauf tippen), Aufgabe (vorgegebene Klausur-Challenges lösen).

Empfehlung für Klausur-Vorbereitung: stell den Slider auf eine Konfiguration die du in der Klausur hattest oder erwartest, klick Auto, schau zu wie die Variable i sich verändert. Nach 5-10 Minuten Spielen hast du Off-by-one-Fehler verinnerlicht.

Mach dir bewusst: Nach dem letzten Durchlauf wird i = 5 und die Bedingung i < 5 ist nicht mehr erfüllt. Die Schleife endet nicht weil i den Wert 5 erreicht, sondern weil die Bedingung falsch wird.

Experiment: Setz den Endwert (das <-Vergleichswert) auf 1. Wie viele Iterationen passieren? Und was passiert wenn Start = End ist?

---

Code-Stepper: Schritt für Schritt durchspielen

Fünf interaktive Demos zu den Schleifenarten und Kontrollanweisungen. Klick Step oder Auto und beobachte, wie sich Variablen und Konsole pro Iteration verändern. Die didaktische Annotation unten am Code zeigt, was in diesem Step passiert.

1. for-Schleife: klassischer Zähler

2. while-Schleife: Zähler-Init und Inkrement manuell

Gleicher Output wie oben, aber du musst alle drei for-Bestandteile (Init, Check, i++) selbst hinschreiben.

3. do-while: Edge-Case mit initial false-Bedingung

Klassische Klausur-Falle: do-while führt den Körper mindestens einmal aus, auch wenn die Bedingung von Anfang an false ist. Hier ist x = 100 und der Check ist x < 5, aber "Hallo" wird trotzdem ausgegeben.

4. break: Schleife verlassen bei i = 5

Hier zählt die for-Schleife eigentlich bis 10, wird aber bei i == 5 mit break komplett abgebrochen.

5. continue: gerade Zahlen überspringen

Im Gegensatz zu break überspringt continue nur die aktuelle Iteration und macht weiter mit der nächsten. Die Schleife läuft also bis zum Ende durch.

Aufgabe: Zahlen 1 bis 10 ausgeben

Schreibe eine Schleife, die alle Zahlen von 1 bis einschließlich 10 ausgibt. Achte auf die Schleifenbedingung, die obere Grenze ist tückisch.

# Tipp: range(start, stop) geht von start bis stop-1
for i in range(1, ___):
    print(i)

1
2
3
4
5
6
7
8
9
10

public class Main {
    public static void main(String[] args) {
        for (int i = /* TODO */; i /* TODO */; i++) {
            System.out.println(i);
        }
    }
}

1
2
3
4
5
6
7
8
9
10