Javaschubla.de - Java als erste Programmiersprache
Schleifen dienen dazu, eine oder mehrere Anweisungen so lange zu wiederholen, wie eine Bedingung wahr ist.
while(Bedingung)
{
... Anweisungen ...
}
"So lange wie die Bedingung wahr ist, führe die Anweisungen aus."
int i = 1;
while (i <= 10)
{
int quadrat = i * i;
System.out.println(quadrat);
i++; // Erinnerung: i++ heißt i = i + 1;
}
gibt die Quadratzahlen von 1*1 bis 10*10 aus.
Zu Anfang wird geprüft, ob i kleinergleich 10 ist, das trifft auf 1 zu, also wird der Schleifenkörper ausgeführt: Das Quadrat von i wird berechnet und ausgegeben, dann wird i auf 2 erhöht. Die Schleife springt zum Anfang, 2 ist auch kleinergleich 10, und so weiter. Letztendlich wird 9*9 ausgerechnet und ausgegeben, i auf 10 erhöht. 10 ist noch kleinergleich 10, 100 wird ausgegeben, i auf 11 erhöht. Die Schleife springt zum Anfang. Die Prüfung 11 <= 10 ergibt false. Der Schleifenkörper wird nicht ausgeführt, der Programmfluss geht in der Zeile nach der Schleife weiter.
Weil vor der ersten Ausführung getestet wird, ob die Bedingung erfüllt ist, ist die while-Schleife eine sogenannte abweisende Schleife. Das ist meistens empfehlenswert. Beispiel für "Abweisung":
int i = 11;
while (int i<=10)
{
System.out.println(i*i);
i++;
}
gibt überhaupt nichts aus.
Aber manchmal braucht man eine Schleife, die mindestens einmal ausgeführt wird. Dafür ist die do-while-Schleife da.
do
{
... Anweisungen ...
}
while (Bedingung);
Beispiel:
int i = 11;
do
{
System.out.println(i*i);
i++;
}
while (i < 10);
gibt 121 aus. (Die Variable i, die in der Bedingung geprüft wird, muss schon vor der Schleife existieren und darf nicht erst in der Schleife definiert werden.)
Ein sinnvolles Beispiel, wo es einen Nutzen bringt, eine do-while-Schleife einzusetzen, wäre, ein Programm zu wiederholen, bis der Benutzer die Frage, ob er es noch einmal ausführen will, mit nein beantwortet. Das Programm wird in der Lektion zum Thema Einlesen von der Tastatur vorgestellt werden.
Dann gibt es noch die sogenannte Zähl- oder for-Schleife. Man benutzt sie besonders häufig, wenn man etwas wie im obigen Beispiel n-mal machen will, von 0 bis n-1 oder 1 bis n oder n bis 1, und wenn man alle Elemente eines Arrays oder eine Collection durchgehen will (was Arrays und Collections sind, kommt später). Aber in Java (und C, C++, C#) sind for-Schleifen genau so flexibel und mächtig wie while-Schleifen.
for (Initialisierung; Bedingung; Inkrement)
{
... Anweisungen ...
}
Beispiel:
for (int i = 1; i <= 10; i++)
{
System.out.println(i*i);
}
ist äquivalent (gleichbedeutend) zu der while-Schleife
int i = 1;
while (i <= 10)
{
System.out.println(i*i);
i++;
}
Das bedeutet insbesondere, dass auch wenn das i++ oben im Kopf der for-Schleife steht, es dennoch am Ende des Schleifenkörpers ausgeführt wird. for (int i = 1; i <= 10; i++) bedeutet also: Beginne bei i = 1, überprüfe (am Anfang, also abweisende Schleife wie while) die Bedingung, führe den Schleifenkörper aus und erhöhe dann i um 1. Dann springe wieder an den Anfang (führe natürlich nicht noch einmal die Initialisierung i = 1 aus) und überprüfe die Bedingung, führ wieder den Schleifenkörper aus und erhöhe i wieder um 1. Und so weiter, genau wie bei der entsprechenden while-Schleife.
i++ und (nicht ganz so häufig) i-- sind die häufigsten Fälle von dem, was als Drittes im Schleifenkopf der for-Schleife steht, aber man könnte auch irgendwas oder gar nichts hineinschreiben.
Eine Anwendung in Verbindung mit Strings: Alle Buchstaben eines Wortes (Strings) sollen einzeln ausgegeben werden:
String s = "hallo";
for (int i = 0; i < s.length(); i++)
{
System.out.println(s.charAt(i));
}
Zur Erinnerung: die Zeichen in einem String sind von 0 bis length()-1 durchnummeriert. Deshalb ist die Initialisierung i = 0 und die Bedingung lautet i < s.length(). Mit s.charAt(i) erhält man das i-te Zeichen.
Nun wollen wir den String rückwärts ausgeben:
String s = "hallo";
for (int i = s.length()-1; i >= 0; i--)
{
System.out.print(s.charAt(i));
}
Wir fangen also beim length()-1-ten (= letzten) Zeichen an und arbeiten uns bis zum 0-ten Zeichen vor. i muss natürlich jeweils dekrementiert (um 1 verringert) statt inkrementiert werden.
Die Variable i hört übrigens mit dem Ende der Schleife auf zu leben:
String s = "hallo";
for (int i = 0; i < s.length(); i++)
{
System.out.println(s.charAt(i));
}
System.out.println(i); // Fehler
An der Stelle wäre i gleich 5 (weil s.length() 5 ist und an der Stelle 5 < 5 nicht erfüllt ist, die Schleife also verlassen wird). Aber sie ist nur innerhalb der Schleife definiert. Der Compiler gibt eine Fehlermeldung aus. Die Variable ist nicht mehr "in scope", sie ist außerhalb ihres Geltungsbereiches. Man könnte hier wieder eine neue Variable namens i definieren, die könnte auch einen anderen Typ haben.
Es gibt seit Java 5.0 auch noch eine andere for-Schleife, die for-in-Schleife. Sie wird benutzt, um alle Elemente eines Arrays oder einer Collection (Sammlung) durchzugehen, deshalb wird sie erst später vorgestelt.
Denk dir eine while, eine do-while und eine for-Schleife aus, oder gleich ein paar mehr.
In der nächsten Lektion wird gezeigt, wie man von der Tastatur einliest. Das ist leider etwas kompiliziert. Falls es dir zu unverständlich erscheint, möchtest du evtl. die Lektion überspringen und erst die zwei danach machen, um dann darauf zurückzukommen.