3.3 For-Schleifen, Teil 1

Zählschleifen

Eng verwandt mit der while-Schleife ist die for-Schleife. Beide Schleifen gehören zu den vorprüfenden Schleifen, das heißt, die Schleifenbedingung wird überprüft, bevor der erste Schleifendurchlauf startet. Daher kann es sein, dass eine solche Schleife NICHT durchlaufen wird, wenn die Bedingung schon vor dem ersten Durchlauf nicht erfüllt ist.

Vergleichen wir einmal eine while-Schleife, die die Zahlen von 1 bis 10 addiert mit einer for-Schleife, die das Gleiche macht:

Vergleich while-Schleife / for-Schleife
Autor: Ulrich Helmich 2025, Lizenz: Public domain

Hier die for-Schleife noch einmal im Quelltext:

// Vorbereitung:
int sum = 0;

// Schleifenkopf:
for (int i=1; i <= 10; i++)

// Schleifenrumpf:
{
   sum += i;
}

Im Grunde ist die for-Schleife eine spezielle while-Schleife. Die Laufvariable oder Zählvariable - hier i - wird im Schleifenkopf deklariert und initialisiert, die Schleifenbedingung befindet sich wie bei der while-Schleife im Schleifenkopf, und die Veränderung - Inkrementierung oder Dekrementierung - der Laufvariable findet bei der for-Schleife auch noch im Schleifenkopf stat.

Bei der while-Schleife aus unserem Beispiel musste die Zählvariable i noch vor der Schleife deklariert und initialisiert werden, und die Inkrementation dieser Variable fand im Schleifenrumpf statt. Bei der for-Schleife werden beide Aufgaben vom Schleifenkopf übernommen, der deswegen auch etwas umfangreicher ist als der Kopf einer while-Schleife.

Syntax von for-Schleifen

Syntaxdiagramm einer for-Schleife und Übertragung auf das Beispiel
Autor: Ulrich Helmich 2025, Lizenz: Public domain

Dieses Bild zeigt links das Syntaxdiagramm einer for-Schleife in senkrecht ausgerichteter Darstellung und rechts die Übertragung des Syntaxdiagramms auf das konkrete Beispiel. Wie immer in solchen Fällen kann der Schleifenrumpf aus einer einfachen Anweisung bestehen oder aus einem Block von Anweisungen, die dann mit geschweiften Klammern {} zusammengefasst werden müssen.

Beispiele für for-Schleifen

For-Schleifen werden in der Regel eingesetzt, wenn man bereits vor dem ersten Schleifendurchgang weiß, wie viele Schleifendurchgänge benötigt werden. Darum werden for-Schleifen auch gern als Zählschleifen bezeichnet. In unserem ersten Beispiel waren das genau 10 Durchgänge. Will man die Zahlen von 1 bis 100 addieren, muss dieser Quelltext nur leicht modifiziert werden:

int sum = 0;
for (int j = 1; j <= 100; j++)
   sum += j;

Auf die geschweiften Klammern für den Schleifenrumpf wurde hier bewusst verzichtet, da dieser nur aus einer einfachen Anweisung besteht.

In dem folgenden Beispiel sollen die Zahlen von 20 bis 1 rückwärts ausgegeben werden:

for (int k = 20; k >= 1; k--)
   System.out.println(k);

Wie man sieht, kann die Laufvariable (Zählvariable) einen beliebigen Namen haben, und sie kann auch um negative Werte inkrementiert werden - man würde dann von einer Dekrementation sprechen. Mit k-- wird der Wert von k um je 1 erniedrigt.

Auch das nächste Beispiel ist interessant:

double y;

for (double xWert = -5; xWert <= 5; xWert += 0.1)
{
   y = x*x - 2*x + 3;
   System.out.println(y);
}

Dieses Beispiel gibt die Funktionswerte y=f(x) für die X-Werte von -5 bis +5 aus, dabei wird der X-Wert immer um 0.1 erhöht. Es können also auch double- oder float-Zahlen als Laufvariablen in Frage kommen. Dies ist aber kein Alleinstellungsmerkmal für for-Schleifen, mit einer while-Schleife hätte man das Gleiche genau so gut hinbekommen.

Zum Schluss noch ein weiteres interssantes Beispiel. Wir hatten ja gesagt, dass der Schleifenrumpf eine einfache Anweisung oder ein Block von Anweisungen sein kann. Eine for-Schleife gilt als eine einfache Anweisung. Das heißt: Eine for-Schleife kann im Schleifenblock eine weitere for-Schleife enthalten:

int produkt;

for (int zeile = 1; zeile <= 10; zeile++)
   for (spalte = 1; spalte <= 10; spalte++)
   {
      produkt = zeile*spalte;
      System.out.println(produkt);
   }

Auf diese Weise könnte man zum Beispiel eine quadratische Funktion auf der Konsole etwas anschaulicher darstellen:

double y;

for ( double x=0; x <= 4; x=x+0.2)
{
   y = x*x - x + 3;

   for (int i=0; i <= y; i++)
       System.out.print(" "); 
		 
   System.out.println("#");
}

Der Schleifenrumpf der äußeren for-Schleife (Laufvariable x) besteht hier aus einer Zuweisung und einer inneren for-Schleife (Laufvariable i). Der Rumpf der inneren Schleife setzt sich wieder aus zwei einfachen Anweisungen zusammen. Der print()-Befehl schreibt y Leerzeichen auf die Konsole, der dann folgende println()-Befehl schreibt das Zeichen '#' ans Ende dieser Zeile und erzeugt dann einen Zeilenumbruch.

Veränderung der Laufvariable im Schleifenrumpf

Eine Sache, die man nach Möglichkeit vermeiden sollte, ist jede Veränderung der Laufvariable im Schleifenrumpf. Betrachten wir dazu folgendes Beispiel:

for (int i = 1; i <= 100; i++)
{
   System.out.println(i); 
   i = i+7;
}

Diese for-Schleife wird problemlos kompiliert, sie enthält keinen lexikalischen oder syntaktischen Fehler. Trotzdem wird sie nicht wie vielleicht erwartet 100 mal durchlaufen, sondern nur 13 mal. Das liegt natürlich daran - Sie haben es bestimmt schon erkannt - dass die Laufvariable i im Schleifenrumpf stark inkrementiert wird.

Im 1. Schleifendurchgang hat i noch den Wert 1. Nachdem die Zuweisung i = i+7 ausgeführt wurde, besitzt i den Wert 8. Und nach Beendigung des Schleifenrumpfs wird i "regulär" im Schleifenkopf inkrementiert, hat dann also vor dem 2. Schleifendurchgang schon den Wert 9.

   public void test2()
   {
       for (int i = 1; i <= 100; i++)
       {
          System.out.println(i); 
          i = i-2;
       }
  }

   public void test3()
   {
       for (int i = 1; i <= 100; i++)
       {
          System.out.println(i); 
          i = i+2;
       }
       System.out.println("Wert von i = " + i);
  }

Typische Fehler beim Umgang mit for-Schleifen

Nicht nur Anfänger und Anfängerinnen, sondern gelegentlich auch professionelle Entwickler machen gelegenlich typische Fehler beim Umgang mit for-Schleifen. Die häufigsten Fehler sind die Folgenden:

1. Falsche Start- oder Endwerte der Laufvariablen

Wir haben in unserem Kurs zwar noch keine Arrys behandelt, das kommt erst im nächsten Abschnitt, aber trotzdem sollten wir schon einmal festhalten, dass ein Array eine Sammlung von mehreren Variablen des gleichen Datentyps ist, und das erste Element dieser Sammlung hat nicht den Index 1, wie man vielleicht erwarten würde, sondern den Index 0. Informatiker fangen gerne mit 0 an zu zählen. Angenommen, ein solcher Array besteht aus 10 Variablen des Typs int, und eine for-Schleife soll die Werte aller 10 Variablen ausgeben, dann wäre der folgende Schleifenkopf falsch:

for (int i=1; i<=10; i++)

Der korrekte Schleifenkopf wäre nämlich

for (int i=0; i < 10; i++)

Nicht nur beim Startwert der Zählvariable muss man aufpassen, sondern auch bei der Überprüfung der Zählvariable in der Schleifenbedingung: i < 10 ist etwas Anderes als i <= 10.

2. Falsche Inkrementation oder Dekrementation der Laufvariablen

Wenn das Inkrement fehlt oder in die falsche Richtung läuft (Dekrementation statt Inkrementation), entsteht schnell eine Endlosschleife oder die Schleife wird gar nicht ausgeführt.

Der folgende Quelltext führt zu einer Endlos-Schleife:

for (int i=1; i <= 10; i--)

Da i stets dekrementiert wird, ist die Schleifenbedingung i <= 10 immer erfüllt. Es kann nie dazu kommen, dass i einmal größer als 10 ist.

Umgekehrt wird die folgende Schleife nie durchlaufen:

for (int i = 10; i <= 0; i++)

Bereits vor dem ersten Durchlauf hat i einen Wert größer als 0, so dass die Schleifenbedingung von Anfang an nicht erfüllt ist.

3. Änderung der Laufvariable im Schleifenrumpf

Das Problem hatten wir bereits weiter oben im Text angesprochen. Technisch ist es möglich, die Laufvariable im Schleifenrumpf zu inkrementieren oder zu dekrementieren, ob das sinnvoll ist, ist aber eine andere Frage. Jedenfalls ist eine solche Veränderung im Schleifenrumpf eine häufige Fehlerquelle.

4. Syntaxfehler

Auch bei for-Schleifen können leicht Syntaxfehler passieren. Beliebt ist beispielsweise die Semikolons im Schleifenkopf durch Kommas zu ersetzen.

for (int i=1, i <= 12, i++)

Dieser Fehler wird allerdings sofort vom Compiler bemerkt.

Ein anderer typischer Syntaxfehler ist das Vergessen von geschweiften Klammern, wenn mehr als eine Anweisung im Schleifenrumpf steht.

Auch ein Semikolon hinter dem Schleifenkopf führt zu einem Fehler, weil der Compiler dies für eine leere Anweisung hält. Die for-Schleife wird dann gar nicht ausgeführt.

for (int i=1; i <= 10; i++);

Wenn dann in dem vermeintlichen Schleifenrumpf auf die Laufvariable zugegriffen wird, merkt der Compiler dies aber sofort, denn außerhalb der for-Schleife ist die Laufvariable nicht definiert.

Übungen am Rechner

Hier kann ich mich sehr kurz fassen: Nehmen Sie sich die Übungen zu den while-Schleifen vor, die Sie in der Folge 3.2, Teil 2 gelöst haben, und ersetzen Sie alle while-Schleifen durch äquivalente for-Schleifen. Das könnte auch durchaus in der Klausur vorkommen, Ersetzung einer vorgegebenen while-Schleife durch eine for-Schleife oder umgekehrt.