Folge 4.2: while-Schleifen

Programmfluss in einer while-Schleife

Der Programmfluss wird in der Regel durch ein Flussdiagramm dargestellt. Schauen wir uns das Flussdiagramm an, das den Programmfluss der Methode fahre(int strecke) zeigt.

Programmfluss der Methode fahre(int strecke)
Autor: Ulrich Helmich, 07/2026, Lizenz: Public Domain

Dieses Flussdiagramm verdeutlicht den Ablauf der while-Schleife.

• Der gewünschte Streckenwert wird der Methode als Parameter übergeben,
• die lokale Variable gefahren wird auf 0 gesetzt,
• danach wird überprüft, ob die Schleifenbedingung gefahren < strecke erfüllt ist,
• ist das der Fall, wird der Schleifenrumpf durchlaufen, der hier aus zwei Anweisungen besteht: dem Methodenaufruf fahre() sowie der Inkrementierung der Variable gefahren,
• danach wird die Schleifenbedingung erneut überprüft – daher führt der Pfeil vom Kasten [gefahren++] zurück zur Entscheidungsraute [gefahren < strecke?],
• Sobald die Schleifenbedingung nicht mehr erfüllt ist, wird die while-Schleife beendet.

Vertiefung: Weitere Beispiele

Wir wollen das Thema "while-Schleifen" nun an einem typischen Lehrbuch-Beispiel vertiefen.

Lehrbuch-Beispiel: Summe 1 .. n

Wir wollen eine Methode schreiben, welche die Summe der Zahlen von 1 bis n berechnet, wobei n der Methode als Parameter übergeben wird.

public int getSumme(int n)
{
   int sum = 0;
   int zahl = 1;
	
   while (zahl <= n)
   {
      sum = sum + zahl;
      zahl++;
   }
		
   return sum;
}

Und hier das zugehörige Flussdiagramm:

Programmfluss der Methode getSumme(int n)
Autor: Ulrich Helmich 07/2026, Lizenz: Public Domain

Vorprüfende Schleifen

In der Fachliteratur liest man oft, dass while-Schleifen zu den vorprüfenden Schleifen gehören. Was ist damit genau gemeint?

Eigentlich ist die Sache ganz einfach: Die Schleifenbedingung muss überprüft werden, bevor der Schleifenkörper durchlaufen wird.

Ist die Schleifenbedingung bereits vor dem ersten Schleifendurchlauf nicht erfüllt, wird der Schleifenrumpf kein einziges Mal ausgeführt. Soll eine Schleife mindestens einmal durchlaufen werden, eignet sich eine while-Schleife daher nicht. In Java verwendet man dafür eine nachprüfende Schleife (do-while-Schleife).

Schritt 4 - Das Auto kann nicht beliebig weit fahren

Unsere Methode fahre(int strecke) enthält noch einen gravierenden Fehler sowie eine kleine Ungenauigkeit. Wir wollen zunächst den Fehler besprechen. Betrachten wir die Methode dazu noch einmal im Quelltext:

public void fahre(int strecke)
{
   int gefahren = 0;

   while (gefahren < strecke)
   {
      fahre();
      gefahren++;
   }
}

Was würde passieren, wenn wir fahre(20000) aufrufen würden, und das bei einem Tankinhalt von 2,3 Litern?

Das Auto würde tatsächlich eine Strecke von 20.000 km zurücklegen, obwohl der Tank bereits nach wenigen Kilometern leer wäre. Beim Fahren ist also darauf zu achten, wie groß die Reichweite des Autos noch ist. Dazu hatten wir ja die Methode

public double getReichweite()
{
   return tankinhalt / verbrauch * 100;
}

für die Klasse Auto geschrieben.

Wie können wir diese Methode nun sinnvoll einsetzen, um die Methode fahre(int strecke) zu verbessern?

Ein erster Ansatz könnte so aussehen:

public void fahre(int strecke)
{
	if (strecke > getReichweite())
	{
		System.out.println("Das Benzin reicht nicht für diese Strecke");
		return;
	}

	int gefahren = 0;

	while (gefahren < strecke)
	{
		fahre();
		gefahren++;
	}
}

Hier wird vor Beginn der while-Schleife geprüft, ob die gewünschte Strecke überhaupt zurückgelegt werden kann. Reicht das Benzin nicht aus, wird eine Fehlermeldung ausgegeben und die Methode mit dem return-Befehl sofort beendet.

Das kann man natürlich so machen, aber das Vorgehen ist wenig praxisnah. Wenn ich von Bielefeld nach Cuxhaven fahren möchte, muss ich 285 km zurücklegen. Der Tank reicht aber nur für 180 km. Damit kann ich problemlos nach Vechta fahren (129 km) und dort tanken, sodass ich doch noch nach Cuxhaven komme.

Wir wollen die Methode daher so verändern, dass möglichst viel von der gewünschten Strecke zurückgelegt wird. Der Tank soll dabei jedoch nicht vollständig geleert werden. Stattdessen soll eine Reserve von 5 Prozent erhalten bleiben, sodass auf jeden Fall noch die nächste Tankstelle erreicht werden kann.

Die folgende Methode leistet genau das:

public void fahre(int strecke)
{
	int gefahren = 0;

	while ((gefahren < strecke) &&
			 (tankinhalt > tankvolumen * 0.05))
	{
		fahre();
		gefahren++;
	}
}

Hier wurde die Schleifenbedingung erweitert. Nun müssen zwei Bedingungen gleichzeitig erfüllt sein:

1. Die gefahrene Strecke muss kleiner sein als die gewünschte Strecke.
2. Der Tankinhalt muss größer sein als die Reserve (5 Prozent des Tankvolumens).

Beide Bedingungen werden mit dem UND-Operator && verknüpft. Nur wenn beide Bedingungen erfüllt sind, hat die gesamte Schleifenbedingung den Wert true. Ist eine der beiden Bedingungen nicht mehr erfüllt, wird die Schleife beendet. Das ist der Fall, wenn entweder das Ziel erreicht wurde oder der Tank fast leer ist.

Aufgaben und Übungen

summe = 0;
x = 100;
while (x > 120)
{
   x = x + 5;
   summe = summe + x;
}

x = 100;
while (x <= 70)
   x = x + 3;

System.out.println(x);

Die letzte Übung zeigt übrigens, dass man auf die geschweiften Klammern verzichten kann, wenn nur eine einzige Anweisung in der while-Schleife steht. In der Fachliteratur wird aber oft empfohlen, auch in solchen Fällen geschweifte Klammern zu benutzen. Das Nichtverwenden dieser Klammern führt oft zu Fehlern. Wenn man beispielsweise den Quelltext im Schleifenrumpf um eine weitere Anweisung ergänzt, vergisst man gern, die Klammern zu ergänzen, auf die man zuvor verzichtet hatte.

					int zaehler = 10;
					int nenner = 3;

if (quotient < Math.PI)
	zaehler++;

double quotient = zaehler / (double) nenner;