Java Schleifen
Willemers Informatik-Ecke
Mithilfe der Abfrage konnten wir feststellen, ob sich ein Fisch in seinem Aquarium wohlfühlt, oder ob es notwendig ist, das Wasser zu kühlen oder zu heizen. Allerdings nutzt die einmalige Feststellung gar nichts, wenn das Aquarium mit seinen Fischen schon eine Stunde später bei 90 Grad Celsius zur Fischsuppe mutiert. Die Abfrage muss wiederholt werden. Und dazu verwendet man Schleifen.

while-Schleife

Die Schleife wird durch das Schlüsselwort while eingeleitet. Es folgt in Klammern die Bedingung, unter der das Programm in der Schleife bleibt. Solange (while) diese Bedingung gilt, verlässt das Programm die Schleife nicht.

Der Schleifenkörper kann aus einer Anweisung oder aus einem Block von Anweisungen bestehen.

while ( Bedingung )
    Anweisung

Betrachten wir noch einmal die Fischabfrage:

if (temp > 15) {
    if (temp < 25) {
        // Dem Fisch geht es gut
    } else {
        // kühlen!
    }
} else {
    // heizen!
}
Umgeben wir die Abfrage mit einer Schleife, die so lange rotiert, wie der Fisch noch lebt, entwickelt sich eine brauchbare Klimasteuerung für das Aquarium.
int temp=18;
boolean fischlebt = true;
while (fischlebt) {
    if (temp > 15) {
        if (temp < 25) {
            // Dem Fisch geht es gut
        } else {
            // kühlen!
        }
    } else {
        // heizen!
    }
    // eine Sekunde schlafen
}
Ein paar Anmerkungen noch:

Beispiel Kapitalentwicklung

Das folgende Beispiel errechnet, wie sich angelegtes Kapital entwickelt, wenn die Zinsen nicht ausgeschüttet werden, sondern beim Kapital bleiben. Dadurch ergeben sich Zinseszinsen. Das Beispiel geht von 6 Prozent Zinsen bei einer jährlichen Sparrate von 2400 Euro aus.

public class Kapital {
   public static void main(String[] args) {
      double kapital = 0.00;
      int jahr = 0;
      while (jahr<10) {
          kapital = kapital * 1.06 + 2400;
          jahr = jahr + 1;
          System.out.print(jahr);
          System.out.print(" - ");
          System.out.println(kapital);
      }
   }
}

Auch für die while-Schleife gibt es einen Syntaxgraph:

Der Spezialist für's Zählen: for

Die Schleife wird durch den Befehl for eingeleitet. Die for-Schleife ist eine spezialisierte while-Schleife. Sie wird überwiegend beim Zählen verwendet.
for  ( Startanweisung ; Bedingung ; EndAnweisung )
    SchleifenAnweisung
Ein Beispiel macht das sofort deutlich:
for (int i=0; i<10; i++) {
    System.out.println(i);
}
Wenn Sie ein Array von 10 Elementen mit 1 füllen wollen, würden Sie folgende Schleife schreiben:
int i;
for (i=0; i<10; i++)
    a[i] = 1;
i=0 ist die Startanweisung. Sie wird genau einmal vor Beginn der Schleife ausgeführt. i<10 ist die Bedingung, die am Schleifenkopf abgefragt wird. Da 0 kleiner als 10 ist, wird die Anweisung a[0]=1 ausgeführt. Am Ende der Anweisung wird die Endanweisung i++ ausgeführt und wieder zum Kopf gesprungen. Die Startanweisung i=0 wird nicht wieder durchgeführt, da sie nur einmalig vor Start der Schleife ausgeführt wird. Aber die Bedingung wird wiederum geprüft.

Insgesamt setzt das Beispiel die Werte von a[0] bis a[9] und damit die ersten zehn Elemente des Feldes a auf 1.

public class Kapital {
   public static void main(String[] args) {
      double kapital = 0.00;
      for (int i=0; i<10; i++) {
          kapital = kapital * 1.06 + 2400;
          System.out.print(i+1);
          System.out.print(" - ");
          System.out.println(kapital);
      }
   }
}

Fußgesteuertes do-while

Sowohl while als auch for fragen zu Beginn der Schleife ab, ob die Bedingung zutrifft. Es gibt aber Anwendungsfälle, wo die Frage nach der Wiederholung erst am Ende der Schleife relevant wird. Ein typisches Beispiel sind Eingaben, die so lange wiederholt werden sollen, bis der Anwender eine gültige Antwort gegeben hat.

Im Gegensatz zur while-Schleife wird die do-Schleife mindestens einmal durchlaufen. Die Bedingung wird am Ende geprüft.

do
    Anweisung
while ( Bedingung )

Der Syntaxgraph sieht so aus

Stillos: break und continue

Mit dem Befehl break können Sie eine Schleife sofort unterbrechen. Diese Vorgehensweise zeugt allerdings nicht von gutem Geschmack. Besser ist es, die Werte der Schleifenbedingung so zu verändern, dass die Schleife bei der nächsten Prüfung aussteigt. Zur Not wird noch eine weitere boolesche Variable in die Bedingung hineingenommen. Das Ziel sollte es jedenfalls sein, eine Unterbrechung so auszuführen, dass durch die Schleifenbedingung eine möglichst klare Auskunft darüber gibt, ob die Schleife durchlaufen wird.
int i=0;
while (true) { // Endlos - kein schöner Stil
    i++;
    if (i>4) {
        break; // An der Schleifenbedingung nicht erkennbar!
    }
    System.out.println(i);
}
Besser:
int i=0;
boolean go = true;
while (go) { // Variable bestimmt die Abbruchbedingung
    i++;
    if (i>4) {
        go = false; // Hier wird go verändert.
    }
    if (go) {
        System.out.println(i);
    }
}
Der Befehl continue übergeht den Rest des Schleifenkörpers, bleibt aber in der Schleife, solange die Bedingung noch erfüllt ist. Dies kann in der Regel mit einem einfachen if übersichtlicher erledigt werden.