Schleifen aussetzen

<-- zurck zur Startseite | <- eine Seite vor | eine Seite weiter ->

  1. die break-Anweisung
  2. Label definieren
  3. die continue-Anweisung

1. die break-Anweisung

Unter Schleifen aussetzen versteht man die Möglichkeit, Anweisungen innerhalb der Schleife zu überspringen oder die Schleife ganz zu verlassen, auch wenn dies nach der Schleifenbedingung noch nicht angezeigt wäre.

Um eine Schleife vorzeitig und unabhängig davon, ob die Schleifenbedingung "true" oder "false" ergibt, abzubrechen und an ihr Ende zu springen, gibt es das Schlüsselwort break. Wir haben es bereits bei der switch-Anweisung kennen gelernt und findet jetzt sowohl in der for- als auch in der while- oder do-Schleife Verwendung. Dabei wird an das Ende der Schleife gesprungen, innerhalb der das Schlüsselwort "break" Anwendung findet. Ein kleines Beispiel:

for (int i=1; i<10; i++) {
   System.out.println("Wert von i: " + i);
   if (i == 5) {
      break;        // wenn i den Wert 5 erreicht, verlasse die Schleife
   }
}

Da dies wenig sinnvoll ist, da man gleich die Zählschleife anders hätte initialisieren können, findet diese Technik oft Anwendung bei Endlosschleifen (z.B. bei einem Programm, das solange Eingaben des Benutzers einliest, bis es durch einen speziellen Befehl abgebrochen wird). Die Ausgabe des Beispiels von oben könnte auch so erreicht werden:

int i=0;
while (true) {
   i++;
   System.out.println("Wert von i: " + i);
   if (i == 5)
       break;
}

nach oben

2. Label definieren

Bei geschachtelten Schleifen wird es etwas problematischer: mit "break" wird ja jeweils nur die innerste Schleife verlassen:

for (int i=1; i<=4; i++) {
   for (int j=1; j<=4; j++) {
       System.out.println("Produkt aus " +i+ " und " +j+ ": " + i*j);
       if (j == 2)
           break;
   }  // die break-Anweisung springt aber nur bis zum Ende dieser Schleife!
}

Beim Eregbnis sehen wir, dass die äußere Schleife ganze vier Durchläufe macht, während die innere Schleife nach dem zweiten Durchlauf abbricht:

screenshot

Um hier an das Ende einer der weiter außen liegenden Klammern zu springen, muss man ein Label definieren. Ein Label dient dazu einer Schleife einen frei wählbaren Namen zu geben, auf die dann mit der break-Anweisung gesprungen werden kann. Dazu wird der Name des Labels hinter die break-Anweisung geschrieben. Korregieren wir unser Beispiel, damit bis ans Ende der äußeren Schleife gesprungen wird:

MeineSchleife:
   for (int i=1; i<=4; i++) {
      for (int j=1; j<=4; j++) {
         System.out.println("Produkt aus " +i+ " und " +j+ ": " + i*j);
         if (j == 2)
             break MeineSchleife;
      }
   } // die break-Anweisung springt nun bis hier!

Ausgedruckt werden jetzt nur zwei Ergebnisse, da beim zweiten Durchlauf der inneren Schleife bis ans Ende der äußeren gesprungen wird und diese verlassen wird:

screenshot

Selbstverständlich kann man auch mehrere Labels definieren und bei Bedarf das Ende der richtigen Schleife ansteuern. Wir geben z.B. auch der inneren Schleife einen Namen und wollen mit der break-Anweisung das Ende der inneren Schleife ansteuern (das entspricht damit dem einfachen break-Befehl ohne Labels):

SchleifeAussen:
   for (int i=1; i<=4; i++) {
      SchleifeInnen:
         for (int j=1; j<=4; j++) {
            System.out.println("Produkt aus " +i+ " und " +j+ ": " + i*j);
            if (j == 2)
               break SchleifeInnen;
         } // die break-Anweisung springt nun bis hier!
   }

nach oben

3. die continue-Anweisung

Während "break" eine Schleife komplett verlässt, kann man mit der Anweisung continue die restlichen Anweisungen in einer Schleife überspringen. Die Schleife wird daraufhin aber nicht verlassen, sondern sie läuft von neuem durch und wird erst beendet, wenn die Schleifenbedingung nicht mehr erfüllt ist. Ihre Verwendung gleicht der der Anweisung "break". Eine leichte Abwandlung des obigen Beispiels:

for (int i=1; i<=4; i++) {
   for (int j=1; j<=4; j++) {
       if (j == 2) {
           continue;   // wenn j den Wert 2 annimmt, &#252;berspringe die restlichen Anweisungen in dieser Schleife
       }
       System.out.println("Produkt aus " +i+ " und " +j+ ": " + i*j);
   }
}

Hier wird, wenn j den Wert 2 annimmt, nur bis ans Ende der inneren Schleife gesprungen und diese von neuem durchlaufen. In der Ausgabe fehlen deshalb lediglich die Werte mit j=2:

screenshot

Vergleicht man die Ausgabe dieses kleinen Beispiels mit der Variante, die "break" benutzt, wird der Unterschied gut sichtbar. Auch für "continue" können Label definiert werden, die analog funktionieren: der continue-Anweisung wir der Name der Schleife übergeben, an deren Ende gesprungen werden soll:

MeineSchleife:
   for (int i=1; i<=4; i++) {
      for (int j=1; j<=4; j++) {
          if (j == 2) {
              continue MeineSchleife;
          }
          System.out.println("Produkt aus " +i+ " und " +j+ ": " + i*j);
      }
   } // Ziel der continue-Anweisung!

Hier wird, wenn j den Wert 2 annimmt, am Ende öußeren Schleife fortgesetzt. Diese wird dann von neuem durchlaufen und die innere Schleife wird wieder neu initiiert, beginnt also wieder bei 1. Die Ausgabe sieht deshalb so aus:

screenshot

nach oben