Unsere erste while-Schleife
Die while-Schleife ist eine vorprüfende Schleife. Betrachten wir das Flussdiagramm und den Quellcode einer while-Schleife, welche die Summe der Zahlen von 1 bis 10 berechnet.
Vor- und nachprüfende Schleifen
Autor: Ulrich Helmich 2025, Lizenz: Public domain
Zunächst werden zwei int-Variablen initialisiert:
int sum = 0;
int i = 1;
Diese beiden einfachen Anweisungen gehören noch nicht zur while-Schleife, sondern dienen der Vorbereitung der Berechnung.
Dann kommt das Schlüsselwort while mit der Schleifenbedingung:
while (i <= 10)
Diese Zeile liest sich fast wie if (i <= 10). Und tatsächlich kann man in älteren Programmiersprachen, die keine while-Schleifen kennen, eine analoge Schleife mit Hilfe der if-Anweisung und des GOTO-Befehls konstruieren, wie im Kasten weiter unten ausgeführt wird.
Wenn die Schleifenbedingung erfüllt ist, also den Wert true hat, dann werden die Anweisungen im Schleifenkörper ausgeführt. Dieser Schleifenkörper ist in der Abbildung rot markiert.
Zunächst wird die Variable sum um den aktuellen Wert von i erhöht:
sum += i;
Dann wird die Variable i um den Wert 1 erhöht:
i++;
Die Variable i hat hier die Funktion einer Zählvariablen oder eines Zählers.
Nach diesen beiden Operationen springt die while-Schleife wieder zurück zur Schleifenbedingung. In BASIC würde man hier den GOTO-Befehl verwenden.
Dann wird geprüft, ob ein zweiter Schleifendurchlauf stattfinden soll. Wenn die Schleifenbedingung immer noch true ist, findet ein zweiter Durchlauf statt. Die Variable sum wird um 2 erhöht (denn i hat jetzt den Wert 2) und so auf den Wert 3 gesetzt. Danach wird i inkrementiert und hat den Wert 3.
Es folgen weitere Schleifendurchläufe, so lange, bis die Bedingung i <= 10 nicht mehr erfüllt ist. Das ist dann der Fall, wenn i im Schleifenkörper auf den Wert 11 gesetzt wurde, nachdem sum um 10 erhöht wurde.
Die while-Schleife wird nun abgebrochen, und es wird der Befehl ausgeführt, der nach der Schleife kommt. In diesem Fall also
System.out.println(sum);
Das Ergebnis der Berechnung - 55 - wird auf der Konsole ausgegeben.
Hier noch einmal der Quelltext unserer ersten while-Schleife im Kopieren und Ausprobieren:
int sum = 0;
int i = 1;
while (i <= 10)
{
sum += i;
i++;
}
System.out.println(sum);
Man kann den gesamten Ablauf einer solchen while-Schleife auch in einer Tabelle darstellen:
| Wert von i | Wert von sum | Bedingung erfüllt |
|---|---|---|
| 1 | 0 | true |
| 2 | 1 | true |
| 3 | 3 | true |
| 4 | 6 | true |
| 5 | 10 | true |
| 6 | 15 | true |
| 7 | 21 | true |
| 8 | 28 | true |
| 9 | 36 | true |
| 10 | 45 | true |
| 11 | 55 | false |
Zum Vergleich: While-Schleife in BASIC
Dieses einfache BASIC-Programm leistet das Gleiche wie unsere erste while-Schleife:
10 i = 1 20 sum = 0 30 IF i <= 10 THEN GOTO 60 40 PRINT "Summe = "; sum 50 END 60 sum = sum + i 70 i = i + 1 80 GOTO 30
In den Zeilen 10 und 20 findet die Vorbereitung der Berechnung statt, die Varialben i und sum werden initialisiert.
In Zeil e 30 wird die Schleifenbedingung mit einer if-Abfrage überprüft. Leider erlaubt klassisches Basic nur eine Anweisung hinter dem Schlüsselwort THEN. Die beiden Berechnungen sum = sum + 1 und i = i + 1 können also nicht direkt hinter dem THEN stehen. Stattdessen finden wir hier einen GOTO-Befehl, der das Programm in die Zeile 60 springen lässt. Dort findet dann die Berechnung statt, und in der Zeile 80 steht ein weiterer GOTO-Befehl, der das Programm wieder zurück zur if-Anweisung springen lässt, die in Zeile 30 steht.
Wenn die if-Bedingung i <= 10 nicht erfüllt ist, wird in Zeile 40 weitergemacht und das Ergebnis der Berechnung ausgegeben. In Zeile 50 kommt dann der Befehl END, und das Programm endet.
Und ein zweiter Vergleich: While-Schleife in FORTRAN
FORTRAN ist eine wesentlich komplexere Sprache als BASIC und wurde hauptsächlich für mathematisch-technische Anwendungen entwickelt. Das gleiche Programm in FORTRAN sähe so aus:
PROGRAM SUMME
INTEGER I, SUM
I = 1
SUM = 0
10 IF (I .LE. 10) THEN
SUM = SUM + I
I = I + 1
GOTO 10
ENDIF
PRINT *, 'Summe = ', SUM
END
Zeilennummern sind hier nicht mehr die Regel, sondern werden nur eingesetzt, um bestimmte Befehlszeilen zu kennzeichnen, so wie hier die if-Bedingung. Nach der Initialisierung der beiden Variablen I und SUM wird gefragt, ob I kleiner oder gleich (LE) als 10 ist. Hinter dem Schlüsselwort THEN können - im Gegensatz zu BASIC - mehrere Befehle stehen. Die Berechnung von SUM sowie die Inkrementierung von I können also direkt nach der if-Abfrage erfolgen. Dann kommt ein Sprung zur Schleifenbedingung mit GOTO 10. Die gesammte if-Bedingung wird mit dem Schlüsselwort ENDIF abgeschllossen. Wie bei den beiden anderen Versionen wird dann das Ergebnis ausgegeben und das Programm beendet.
Seitenanfang
Weiter mit while-Schleifen, Teil 2 ...