int i = 0;
System.out.println(i);    //Ausgabe: 0
i++;
System.out.println(i);    //Ausgabe: 1
i++;
System.out.println(i);    //Ausgabe: 2
i++;
System.out.println(i);    //Ausgabe: 3

Wie wir sehen, erzeugen wir uns zunächst eine Variable, die einen Wert von 0 zugewiesen bekommt und dann der Wert der Variablen ausgegeben wird. Danach wird der Wert der Variablen um eins erhöht und es erfolgt wieder eine Ausgabe … usw. Nun, da Programmierer schreibfaul sind und dieser Code einfach zu umständlich erscheint, gibt es in vielen Programmiersprachen Schleifen, die dazu dienen einen bestimmten Code mehrmals auszuführen. Programmiersprachen, die keine Schleifen unterstützen, verwenden oft das Konzept der Rekursion – dies unterstützt Java auch.

Java kennt hierbei drei Arten von Schleifen:

• while-Schleife
• do-while-Schleife
• for-Schleife

Schleifen bestehen immer aus einer Schleifenbedingung und dem Rumpf. In der Schleifenbedingung befindet sich ein boolescher Ausdruck, der der Schleife sagt wie lange der im Rumpf stehende Programmcode wiederholt werden soll.

Wenden wir uns zunächst der while-Schleife zu und betrachten dazu den oben abgewandelten Code in “Schleifen-Schreibweise”:

int i = 0;
while(i <= 3)
{
  System.out.println(i);
  i++;
}

Compilieren wir nun dieses Code-Fragment, so sollten wir das gleiche Ergebnis wie oben erhalten. Doch was passiert nun hier? Zunächst erstellen wir wie oben die Variable i und weisen ihr den Wert 0 zu. Danach sehen wir die while-Schleife in Gebrauch. In den runden Klammern finden wir die Bedingung, die der Schleife sagt, wie lange sie wiederholt werden soll – nämlich so lange wie unser i kleiner-gleich drei ist. Nun gelangen wir in den Rumpf der Schleife. Wie wir sehen findet dort lediglich die Ausgabe von i statt. Danach wird i um eins erhöht. Das Erhöhen der Variablen dürfen wir nicht vergessen, denn sonst bekämen wir eine Endlosschleife, die theoretisch unendlich lang ausgeführt wird. Naja, Theorie und Praxis sehen hierbei anders aus, denn entweder erkennt unser Betriebssystem, dass es sich hier um Code handelt, der nicht vorwärts kommt und bricht diesen ab, oder wir brechen ihn selber ab, weil es uns zu doof ist so lange zu warten, oder uns schmiert irgendwann das System ab und wir müssen den Rechner neu starten.
Schauen wir uns nun den obigen Code umgewandelt in eine for-Schleife an:

for(int i = 0; i <= 3; i++)
{
  System.out.println(i);
}

Was macht nun dieses Stück Code? In der for-Schleife deklarieren wir die Variable in den runden Klammern und weisen ihr den Wert 0 zu. Nach dem Semikolon folgt dann die Bedingung, die die gleiche ist wie bei der while-Schleife. Ein Semikolon weiter schreiben wir das rein, was mit unserer Zählvariablen i gemacht werden soll – sie wird um eins erhöht.
Die Syntax einer for-Schleife sieht folgendermaßen aus:

for(Zählvariable; Bedingung; Erhöhung der Zählvariablen)
{
Code im Rumpf
}

Der Code im Rumpf der Schleife wird so lange wiederholt, bis i den Wert von drei übersteigt.

Jetzt tun uns noch die do-while-Schleife und haben dieses Kapitel auch hinter uns
Zunächst einmal wenden wir uns wieder einem Code-Beispiel zu:

do
{
  System.out.println(i);
  i++;
}
while(i <= 3);

Okay, die do-while-Schleife unterscheidet sich von der while-Schleife einmal, dass da das “do” vor dem “while” steht und dadurch, dass eine do-while-Schleife mindestens einmal ausgeführt wird. Haben wir also eine Bedingung, die von vornherein “false” ist, so findet bei der while- und der for-Schleife keine Ausführung des Codes im Rumpf statt – jedoch bei der do-while-Schleife.

Nun sollte sich die Frage stellen wann man welche Schleife verwenden sollte. Bei der do-while-Schleife sollte es klar sein, dass man diese nutzt, um Code mindestens einmal ausgeführt zu haben. Bei der for- und while-Schleife ist es Wurschd, denn vom Aufwand her sollten beide gleich sein.

Also, noch ein fröhliches Coden … =)