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.
Eine klassische for-Schleife in Java besteht aus drei Teilen, getrennt durch Semikolons:
java// snippet
for (int i = 0; i < 5; i++) {
System.out.println("Runde " + i);
}
Initialisierung, Bedingung, Inkrement. In dieser Reihenfolge.
Der Computer führt diese Schritte aus:
int i = 0 einmal am Anfang
i < 5 prüfen, falls wahr weitermachen, sonst Schleife beenden
Schleifenkörper ausführen (in dem Fall: println)
i++ ausführen (i um 1 erhöhen)
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:
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.
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.
while prüft die Bedingungvor 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++;
}
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.
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:
Initialisierung, Invariante gilt VOR dem ersten Durchlauf.
Erhaltung, wenn die Invariante vor dem Körper gilt, gilt sie auch nach i++ wieder.
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]."
Schritt
Argument
Init
i=1, max=zahlen[0]. zahlen[0..0] ist nur {zahlen[0]}, dessen Max ist zahlen[0] = max ✓
Erhaltung
Vor dem Körper: max = Max(zahlen[0..i-1]). Im Körper wird max ggf. auf zahlen[i] hochgesetzt → nach Körper: max = Max(zahlen[0..i]). Dann i++ → Invariante mit neuem i ist wieder Max(zahlen[0..i-1]) ✓
Term
Schleife endet bei i = zahlen.length. Invariante: max = Max(zahlen[0..length-1]) = Max des gesamten Arrays ✓
Die Invariante ist der rote Faden der die Schleife korrekt macht.
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.
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 Variablei sich verändert. Nach 5-10 Minuten Spielen hast du Off-by-one-Fehler verinnerlicht.
Lade Visualisierung...
Mach dir bewusst: Nach dem letzten Durchlauf wird i = 5 und die Bedingungi < 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?
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
Lade Visualisierung...
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.
Lade Visualisierung...
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.
Lade Visualisierung...
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.
Lade Visualisierung...
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.
Lade Visualisierung...
Schreibe eine Schleife, die alle Zahlen von 1 bis einschließlich 10 ausgibt. Achte auf die Schleifenbedingung, die obere Grenze ist tückisch.
Übung · java
Ausführung kommt vor Launch
Aufgabe
Vervollständige die Schleife, sodass die Zahlen 1, 2, 3, ..., 10 ausgegeben werden.
Editor wird geladen...
Anmelden, um den Fortschritt zu speichern.
Nächster Schritt
Wenn du fertig bist: jetzt üben.
Aktives Abrufen festigt Wissen schneller als nochmal lesen.
War das hilfreich?
Fachliche Qualität
S-Tier · GoldstandardZuletzt geprüft am 17.05.2026
Diese Lerneinheit wurde für typische Bachelor-Klausuren konzipiert. So prüfen wir · Fehler entdeckt? Melde ihn uns oder markiere die fragliche Stelle direkt im Text oben.
Klausur-ÜbersichtKomplette Übersicht: alle Tabs als linearer Text zum Lernen
▾
Alle Tabs der Lerneinheit (Erklärung · Interaktiv · Übung · Quiz) als durchgehender Text. Ideal zum Wiederholen vor der Klausur, und für Suchmaschinen wie Google, Bing und KI-Suche (ChatGPT, Perplexity).
Teil 1·Erklärung
Erklärung
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:
Beispiel-CodeJava
for (int i = 0; i < 5; i++) {
System.out.println("Runde " + i);
}
Initialisierung, Bedingung, Inkrement. In dieser Reihenfolge.
Beispiel-CodePython
for i in range(5):
print(f"Runde {i}")
range(5) liefert beim Iterieren die Werte 0, 1, 2, 3, 4 (in Python 3 ist range ein Range-Objekt, keine fertige Liste). Python-for iteriert allgemein über Iterables.
Der Computer führt diese Schritte aus:
int i = 0 einmal am Anfang
i < 5 prüfen, falls wahr weitermachen, sonst Schleife beenden
Schleifenkörper ausführen (in dem Fall: println)
i++ ausführen (i um 1 erhöhen)
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:
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 oder 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.
Teil 2·Visualisierung / Interaktiv
Interaktiv
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 Variablei sich verändert. Nach 5-10 Minuten Spielen hast du Off-by-one-Fehler verinnerlicht.
Interaktive Visualisierung
Animiert for- und while-Schleifen Schritt für Schritt mit Bedingungs-Check und Inkrement.
Mach dir bewusst: Nach dem letzten Durchlauf wird i = 5 und die Bedingungi < 5 ist nicht mehr erfüllt. Die Schleife endet weil i den Wert 5 erreicht, sondern weil die Bedingung falsch wird.
Teil 3·Code-Übung
Übung
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.
Aufgabe / Code-Übung
Vervollständige die Schleife, sodass die Zahlen 1, 2, 3, ..., 10 ausgegeben werden.
Starter-CodePython
# Tipp: range(start, stop) geht von start bis stop-1
for i in range(1, ___):
print(i)
Erwartete Ausgabe
1
2
3
4
5
6
7
8
9
10
Hinweise anzeigen (2)
range(1, 10) geht von 1 bis 9. Du brauchst aber bis 10.
Die obere Grenze in range() ist exklusiv. Setz sie auf 11.
Aufgabe / Code-Übung
Vervollständige die Schleife, sodass die Zahlen 1, 2, 3, ..., 10 ausgegeben werden.
Teil 4·Quiz / Klausurfragen
Quiz
Klausurfragen mit Lösungen (7)
F1.Was gibt diese Schleife aus?
for (int i = 0; i < 3; i++) { System.out.print(i); }
Antwort: 012
Erklärung: Die Schleife startet bei i=0 und läuft solange i < 3, also für i = 0, 1, 2. Drei Iterationen, drei Ausgaben.
F2.Wie oft wird der Schleifenkörper ausgeführt?
for (int i = 5; i > 0; i--) { /* ... */ }
Antwort: 5 mal
Erklärung: Die Schleife läuft für i = 5, 4, 3, 2, 1. Bei i = 0 ist die Abbruchbedingung erreicht. Fünf Iterationen.
F3.Welche Schleife ist eine Endlosschleife (sofern nicht abgebrochen)?
Antwort: Zähler startet bei 0, läuft solange < 5, wird runtergezählt
Erklärung: Bei Option 3 startet der Zähler bei 0 und wird KLEINER. Die Bedingung 'kleiner als 5' bleibt also immer wahr, der Zähler entfernt sich nur weiter von der Grenze. Endlosschleife.
while prüft die Bedingungvor 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++;
}
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:
Initialisierung, Invariante gilt VOR dem ersten Durchlauf.
Erhaltung, wenn die Invariante vor dem Körper gilt, gilt sie auch nach i++ wieder.
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]."
Schritt
Argument
Init
i=1, max=zahlen[0]. zahlen[0..0] ist nur {zahlen[0]}, dessen Max ist zahlen[0] = max ✓
Erhaltung
Vor dem Körper: max = Max(zahlen[0..i-1]). Im Körper wird max ggf. auf zahlen[i] hochgesetzt → nach Körper: max = Max(zahlen[0..i]). Dann i++ → Invariante mit neuem i ist wieder Max(zahlen[0..i-1]) ✓
Term
Schleife endet bei i = zahlen.length. Invariante: max = Max(zahlen[0..length-1]) = Max des gesamten Arrays ✓
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.
nicht
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
Interaktive Visualisierung
Interaktive Komponente: probiere sie im Topic-Player oben aus.
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.
Interaktive Visualisierung
Interaktive Komponente: probiere sie im Topic-Player oben aus.
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.
Interaktive Visualisierung
Interaktive Komponente: probiere sie im Topic-Player oben aus.
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.
Interaktive Visualisierung
Interaktive Komponente: probiere sie im Topic-Player oben aus.
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.
Interaktive Visualisierung
Interaktive Komponente: probiere sie im Topic-Player oben aus.
Starter-Code
Java
public class Main {
public static void main(String[] args) {
for (int i = /* TODO */; i /* TODO */; i++) {
System.out.println(i);
}
}
}
Erwartete Ausgabe
1
2
3
4
5
6
7
8
9
10
Hinweise anzeigen (2)
Starte i bei 1, nicht bei 0.
Die Bedingung muss bei i = 10 noch wahr sein, also i <= 10.
Wie oft wird die Schleife ausgeführt?
int sum = 0;
for (int i = 1; i <= 100; i++) { sum += i; }
Antwort: 100 Iterationen
Erklärung: Die Schleife läuft von i=1 bis i=100 (inklusive). 100 Iterationen total. Zur Erinnerung: in Python `range(1, 101)` ist exklusive obere Grenze, 100 ist die letzte Zahl die durchläuft. In Java steht `<=` daher genauso.
Typ: Zahlen-Eingabe
F5.Eine do-while-Schleife in Java führt den Körper immer mindestens einmal aus, auch wenn die Bedingung von Anfang an falsch ist.
Antwort: Wahr
Erklärung: Bei `do { ... } while (cond);` wird der Körper zuerst ausgeführt, dann die Bedingung geprüft. Selbst wenn cond initial false ist, läuft der Körper genau einmal. Bei einer normalen `while (cond) { ... }` wird die Bedingung VOR dem Körper geprüft → ggf. null Iterationen. **Python hat keine native `do-while`-Schleife**, man simuliert das Muster meist mit `while True` und `break`.
Typ: Wahr/Falsch
F6.Was bewirkt das Schlüsselwort break innerhalb einer Schleife?
Antwort: Verlässt die Schleife sofort komplett
Erklärung: `break` bricht die Schleife sofort ab, die Programmausführung springt direkt zur Anweisung NACH der Schleife. Wenn du nur die aktuelle Iteration überspringen willst, nutzt du `continue`. Klausur-Klassiker zur Unterscheidung break vs continue.
F7.Welche Schleifeninvariante beschreibt diesen Code korrekt? Gesucht: das Maximum eines int-Arrays.
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];
}
}
Antwort: max == Maximum von zahlen[0..i-1]
Erklärung: Die Invariante gilt **vor jedem Schleifendurchlauf**. Vor dem ersten Durchlauf ist i=1, max=zahlen[0] → max ist das Maximum von zahlen[0..0] = zahlen[0..i-1]. Im Körper wird zahlen[i] mit max verglichen, danach i++ → die Invariante "max == Max von zahlen[0..i-1]" gilt wieder. Nach dem letzten Durchlauf ist i == zahlen.length, also enthält max das Maximum des gesamten Arrays. Option 3 ist falsch, weil zahlen[i] erst NACH dem if-Check in den Vergleich aufgenommen wird, nicht VOR dem Iterationsbeginn.
