C. Die for-Schleife

Die while-Schleife hat zwei große Nachteile:

1. Zum bloßen Zählen ist sie sehr umständlich, da insgesamt drei Zeilen benötigt werden:

int i = 0;         // Deklaration (und Initialisierung) der Zählvariable
while(i <= 10) {   // Bedingung
                   // Anweisungen
   i++;            // Erhöhung der Zählvariable
}
2. Oft stehen zwischen der Deklaration der Zählvariable und der Bedingung sowie zwischen der Bedingung und der Erhöhung der Zählvariable sehr viele Anweisungen und es ist schwer, „auf einen Blick“ zu erfassen, wie oft wiederholt wird und welche Werte die Zählvariable bei jedem Wiederholungsschritt annimmt.

Für alle Anwendungsfälle, in denen auf irgendeine Art und Weise gezählt wird, verwendet man daher üblicherweise eine Kurzschreibweise der while-Schleife, die for-Schleife. Hier eine Gegenüberstellung der beiden. Beide Programme sind gleichwertig, machen also dasselbe:

While-loop For-loop
while for

Die for-Schleife ist eine Kurzform der while-Schleife. Sie besteht aus drei Bestandteilen: 

for (Startanweisung; Bedingung; Anweisung am Ende jedes Wiederholungsschrittes) {
   // Anweisungen
}
Wichtig zu beachten ist:
  • Die Startanweisung wird genau 1-mal zu Beginn aufgerufen.
  • Die Bedingung wird vor jedem Wiederholungsschritt ausgewertet. Ist ihr Wert true, so werden die Anweisungen in den {} ausgeführt. Ist der Wert false, so werden die Anweisungen in den {} übersprungen und es wird mit der Anweisung hinter der for-loop fortgefahren.
  • Die Anweisung am Ende jedes Wiederholungsschrittes wird am Ende jedes Wiederholungsschrittes ausgeführt. Also die Variable, die dort hochgezählt wird, wird erst dann verändert, wenn alle Anweisungen in den geschweiften Klammern ausgeführt wurden

Für Einsteiger ist die for-Schleife oft schwer zu verstehen, weil ihre drei Bestandteile jeweils ganz unterschiedliche Bedeutung haben. Noch dazu ist der 1. und 3. Bestandteil eine Anweisung, der 2. Bestandteil eine Bedingung (genauer: eine Aussage).

Lass' Dich nicht entmutigen: Meist wird die for-Schleife zum Zählen benutzt und sieht so oder ähnlich aus: 

for (int i = 1; i <= 10; i++) {
   // Anweisungen
}

Dieses Muster (das in diesem Fall die Anweisungen für i-Werte von 0 bis 9 durchführt) wirst Du sehr schnell beherrschen und - von diesem Muster ausgehend - bald auch schwierigere Konstruktionen mit for verstehen.

Führe die folgenden Programme in Einzelschritten aus („Step over"), und zwar

  • zunächst mit offenem Tab „Ausgabe“ auf der rechten Seite
  • dann mit offenem Tab „Variablen“ auf der rechten Seite.

Beobachte genau, was jeder einzelne Programmschritt bewirkt!

Beispiel 6: Zählen mit "for"

Wir schreiben den Text „Hallo Welt!“ 10-mal untereinander in die Ausgabe. Mit der Variablen i zählen wir dabei, wie oft wir ihn schon ausgegeben haben.

Erklärung

Die for-loop bewirkt, dass der Rechner folgendes macht:

Anweisung Erklärung Wert von i nach der Anweisung
int i = 1; Die Variable i wird deklariert ("bekannt gemacht") und mit der Zahl 1 initialisiert ("vorbelegt"). 1
Prüfe: Ist i < 10? Das Ergebnis der Prüfung ist true, da 1 <= 10 ist. Daher wird als nächste die Anweisung in {} ausgeführt. 1
println(„Hallo Welt (zum “ + i + „-ten Mal)!“); Es wird ausgegeben: Hallo Welt (zum 1. Mal)! 1
i++; Am Ende des Wiederholungsschrittes wird i++ ausgeführt und damit der Wert von i um 1 erhöht. Der Rechner setzt die Ausführung in Zeile 1 fort. 2
Prüfe: Ist i < 10? Das Ergebnis der Prüfung ist true, da 2 <= 10 ist. Daher wird als nächste die Anweisung in {} ausgeführt. 2
println(„Hallo Welt (zum “ + i + „-ten Mal)!“); Es wird ausgegeben: Hallo Welt (zum 2. Mal)! 2
i++; Am Ende des Wiederholungsschrittes wird i++ ausgeführt und damit der Wert von i um 1 erhöht. Der Rechner setzt die Ausführung in Zeile 1 fort. 3

usw…

Die letzten Schritte sehen so aus:

println(„Hallo Welt (zum “ + i + „-ten Mal)!“); Es wird ausgegeben: Hallo Welt (zum 9. Mal)! 9
i++; Am Ende des Wiederholungsschrittes wird i++ ausgeführt und damit der Wert von i um 1 erhöht. Der Rechner setzt die Ausführung in Zeile 1 fort. 10
Prüfe: Ist i < 10? Das Ergebnis der Prüfung ist true, da 10 <= 10 ist. Daher wird als nächste die Anweisung in {} ausgeführt. 10
println(„Hallo Welt (zum “ + i + „-ten Mal)!“); Es wird ausgegeben: Hallo Welt (zum 10. Mal)! 10
i++; Am Ende des Wiederholungsschrittes wird i++ ausgeführt und damit der Wert von i um 1 erhöht. Der Rechner setzt die Ausführung in Zeile 1 fort. 11
Prüfe: Ist i < 10? Das Ergebnis der Prüfung ist false, da nicht 11 <= 10 ist. Daher wird jetzt die Anweisung in {} übersprungen und es geht in Zeile 4 weiter! 11
println(„Fertig!“, Color.lightgreen);

Beispiel 7: Zählen im Dreierschritt

Du erinnerst Dich sicher: n += 3 ist eine Kurzschreibweise für n = n + 3 und bewirkt, dass der Wert der Variable n um 3 erhöht wird.

Beispiel 8: Berechnung von 8!

Berechnung von Fakultäten

Die Faktultät einer Zahl n, kurz n!, ist folgendermaßen definiert: n! = 1 * 2 * 3 * 4 * ... n. Es ist beispielsweise 5! = 1 * 2 * 3 * 4 * 5 = 120.

Probiere das Programm wieder in Einzelschritten aus und schau' Dir die Belegung der Variablen nach jedem Schritt an!

  • Du kannst die 8 in der ersten Zeile natürlich auch durch eine andere Zahl ersetzen!
  • Warum wird der Variablen fakultät in Zeile 2 der Startwert 1 zugeordnet und nicht 0?
    (Falls Du nicht auf die Antwort kommst, probier' es aus, indem Du die 1 im Programm durch 0 ersetzt!)

Aufgaben zur for-Loop

>Hier geht's zu den Aufgaben....

Learning Outcomes
  • Ohne Wiederholungen oder auch Schleifen gibt es keine Programmierung
  • Es gibt 3 grundlegende Schleifenarten:
    1. while-Schleife (kopfgesteuert)
    2. do ... while-Schleife (fußgesteuert)
    3. for-Schleife
  • 1. while-Schleife:

    while (Bedingung) {
       // Anweisungen
    }

    Die Anweisungen werden wiederholt, solange die Bedingung zutrifft, also den Wert true hat. 
  • do {
    // Anweisungen
    } while (Bedingung);

    Die Anweisungen werden wiederholt, solange die Bedingung zutrifft, also den Wert true hat. 
    Die Art von Schleife kommt nicht so häufig vor.
  • Die for-Schleife ist eine Kurzform der while-Schleife. Sie besteht aus drei Bestandteilen:

    for (Startanweisung; Bedingung; Anweisung am Ende jedes Wiederholungsschrittes){
       // Anweisungen
    }

    Die Startanweisung wird genau 1-mal zu Beginn aufgerufen.
    Die Bedingung wird vor jedem Wiederholungsschritt ausgewertet. Ist ihr Wert true, so werden die Anweisungen in den {} ausgeführt. Ist der Wert false, so werden die Anweisungen in den {} übersprungen und es wird mit der Anweisung hinter der for-Schleife fortgefahren.
    Die Anweisung am Ende jedes Wiederholungsschrittes wird am Ende jedes Wiederholungsschrittes ausgeführt.