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
- Zählvariable
-
while-Schleife:- Sie wird verwendet, wenn die Anzahl der Wiederholungen nicht bekannt ist.
- endet, wenn eine bestimmte Bedingung nicht mehr erfüllt 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.
¶ for-Schleife
- Die
for-Schleife ist eine kompakte Schreibweise für Zählschleifen. - Die Bedingung wird vor jedem Durchlauf geprüft .
for (initialisierung; bedingung; update) {
// Codeblock, der wiederholt ausgeführt wird
}
// Beispiel
for (int i = 0; i < 10; i++) {
System.out.println("Die aktuelle Zahl ist: " + i);
}
¶ Ablauf:
- Initialisierung (einmalig):
- 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 prüfen:
- Laufe, solange eine Bedingung wahr bleibt bzw:
while(true) - 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
- Laufe, solange eine Bedingung wahr bleibt bzw:
- Update:
- Die Zählvariable bekommt einen neuen Wert.
- Wie dieser berechnet wird, steht in diesem Block
- Zurück zur Bedingung
¶ UML-Diagramm:
¶ while-Schleife
-
Die
while-Schleife prüft die Bedingung vor jedem Durchlauf -
Auch hier: Laufe, solange eine Bedingung wahr bleibt bzw:
while(true) -
Wenn die Bedingung von Anfang an
falseist, wird der Code kein einziges Mal ausgeführt . -
while-Loops sind flexibler bei einer unbekannten Zahl von Iterationen. -
wenn eine Menge von Einträgen zu durchlaufen sind, wir aber nicht wissen, wie viele genau das sein werden.
-
Keine Zählvariable (Falls wir eine solche Variable haben wollen, müsste diesevon 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.
while (bedingung) {
// Code
}
Scanner scanner = new Scanner(System.in);
int input = 0;
while (input < 5) {
System.out.println("Gib eine Zahl größer als 5 ein, um die Schleife zu beenden:");
input = scanner.nextInt();
}
scanner.close();
¶ Ablauf:
- Bedingung prüfen
- Wenn
true→ Code ausführen - Danach wieder zur Bedingung
¶ UML-Diagramm:
¶ do-while-Schleife
Die do-while-Schleife prüft die Bedingung erst nach dem Durchlauf .
Dadurch wird der Code mindestens einmal ausgeführt , egal ob die Bedingung true oder false ist.
do {
// Code
} while (bedingung);
¶ Ablauf:
- Code ausführen
- Bedingung prüfen
- Wenn
true→ wiederholen
¶ UML-Diagramm:
¶ 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)
import java.util.Random;
public class WuerfelSpiel {
public static void main(String[] args) {
Random random = new Random();
int wurf = 0;
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.");
}
}
¶ Zusammenfassung
- Alle Schleifen arbeiten nach dem Prinzip: „solange die Bedingung wahr ist“
- Unterschied liegt im Zeitpunkt der Prüfung :
while→ vorherfor→ vorher (mit zusätzlicher Struktur)do-while→ nachher (läuft immer mindestens einmal)