while-Schleife: Einführung und wichtige Nuancen

1. Einleitung

In der Programmierung muss man regelmäßig ein und dieselben Aktionen viele Male hintereinander ausführen. Zum Beispiel:

• Alle Elemente einer Liste durchlaufen.
• Werte von der Tastatur einlesen, bis der Benutzer den gewünschten Wert eingibt.
• Die Summe aller Zahlen von 1 bis 100 berechnen.
• Den Benutzer so lange nach einem Passwort fragen, bis es richtig ist.

Wenn man versucht, all das ohne Schleifen zu implementieren, wird es lang, langweilig und nicht skalierbar. Stellen Sie sich vor, Sie schreiben ein Taschenrechner-Programm und beschließen, die Zahlen von 1 bis 10 von Hand zu addieren:

int sum = 0;
sum = sum + 1;
sum = sum + 2;
sum = sum + 3;
// ... und so 10 Mal. Tja.

Sie werden sich langweilen, noch bevor Sie fertig sind! Die Lösung – Schleifen. Sie ermöglichen es, Wiederholungen knapp und verständlich zu beschreiben. Heute lernen wir die grundlegendste, aber verdammt nützliche Schleife kennen – while.

2. Bekanntschaft mit der while-Schleife

Syntax und Grundschema

Die while-Schleife ist der „Papagei“ in der Programmierwelt: Sie wiederholt ein und denselben Codeabschnitt so lange, wie eine bestimmte Bedingung erfüllt ist. Sobald die Bedingung nicht mehr wahr ist, verstummt der Papagei (die Schleife endet).

Syntax:

while (condition)
{
    // Schleifenkörper
}

Diagramm

Hier ist ein einfaches Flussdiagramm zum Verständnis der while-Schleife:

3. Beispiele: die while-Schleife in Aktion

Klassischer Zähler

Schreiben wir ein einfaches Programm, das von 1 bis 5 zählt und die Zahlen ausgibt:

int i = 1;
while (i <= 5)
{
    System.out.println("Schritt Nr. " + i);
    i++; // Vergessen Sie nicht, den Zähler zu erhöhen!
}
// Ausgabe:
// Schritt Nr. 1
// Schritt Nr. 2
// Schritt Nr. 3
// Schritt Nr. 4
// Schritt Nr. 5

Achtung: Wenn man vergisst, die Variable i zu erhöhen, endet die Schleife nie (unser Papagei wird unsterblich und wiederholt ewig). Das nennt man eine Endlosschleife – eine ziemlich beängstigende Sache.

Eingabe von der Tastatur bis zum gewünschten Wert

Häufig wird eine Schleife verwendet, um den Benutzer so lange zur richtigen Eingabe zu bewegen:

String password = "";
while (!password.equals("qwerty"))
{
    System.out.print("Geben Sie das Passwort ein: ");
    password = console.nextLine();
}
System.out.println("Willkommen!");

Hier bittet das Programm um die Passworteingabe, bis Sie das magische "qwerty" tippen. Vergessen Sie nicht: Wenn Sie die Zeile password = console.nextLine(); entfernen, wird die Schleife wieder endlos (sie fragt nach dem Passwort, liest aber keine Eingabe – bleibt für immer hängen, wie ein kaputter Roboter).

4. Arten und Einsatzszenarien der while-Schleife

Gewöhnliche while-Schleife

Diese Schleife prüft die Bedingung vor der ersten Iteration. Ist die Bedingung sofort falsch, wird der Schleifenkörper kein einziges Mal ausgeführt.

Beispiel: Die Bedingung ist von Anfang an nicht erfüllt

int i = 10;
while (i < 5)
{
    System.out.println(i); // Wird niemals ausgeführt!
}

Was ja auch logisch ist. Genau so, wie hier steht.

Verschachtelte while-Schleifen

Manchmal braucht man eine Schleife in der Schleife. Zum Beispiel alle Zeilen durchlaufen und in jeder alle Zeichen prüfen. Auf diesem Stand ist das eher abenteuerlich, aber hier ist ein einfaches Beispiel:

int i = 1;
while (i <= 3)
{
    int j = 1;
    while (j <= 2)
    {
        System.out.println("i = " + i + ", j = " + j);
        j++;
    }
    i++;
}

// i = 1, j = 1
// i = 1, j = 2
// i = 2, j = 1
// i = 2, j = 2
// i = 3, j = 1
// i = 3, j = 2

Ausführlicher besprechen wir verschachtelte Schleifen in ein paar Vorlesungen, ich wollte Sie nur ein wenig erschrecken :)

Endlosschleife

Manche Schleifen enden, und manche – leben ewig.

while (true)
{
    System.out.println("Ich bin ewig!");
}

Wird selten verwendet, meist für irgendwelche Hintergrundprozesse (z. B. den Betrieb eines Servers), kommt aber in der Praxis vor.

5. Wie man keinen Unsinn baut: häufige Fehler mit while

In der Programmierung ist eine Schleife wie Elektrizität: großartig, aber man muss die Sicherheitsregeln kennen.

Problem 1: Endlosschleife aus Unachtsamkeit

Sehr oft vergessen Anfänger, die Variable zu aktualisieren, von der die Bedingung abhängt. Das Ergebnis ist eine „endlose“ Schleife, und man muss das Programm zwangsweise stoppen (z. B. mit der Tastenkombination Ctrl + C).

int i = 1;
while (i <= 5)
{
    System.out.println(i);
    // i++;  // Ups! i zu erhöhen vergessen
}

Problem 2: Falsch formulierte Bedingung

Manchmal gräbt sich der Entwickler selbst eine Grube: Die Bedingung ist umgekehrt nie wahr. Infolgedessen wird die Schleife überhaupt nicht ausgeführt.

int i = 10;
while (i < 5)
{
    System.out.println(i); // Dieser Code wird niemals ausgeführt.
    i++;
}

Problem 3: Fehler beim Datentyp

In der Schleifenbedingung muss stets ein boolescher Ausdruck stehen – das heißt, das Ergebnis der Auswertung muss true oder false sein.

int number = 5;
while (number) // Fehler! Erwartet wurde boolean, nicht int.
{
    number--;
}