» Tutorial / Java Grundlagen / Schleifen

Schleifen sind Anweisungen, die eine oder mehrere Anweisungen beliebig oft ausführen können. Zu deren Kontrolle stehen dem Programmierer verschiedene Typen und Bedingungen zur Verfügung.


» While
» Do While
» For
» Break und Continue
» Endlosschleifen


» While nach oben «

Unsere erste Betrachtung gilt der While - Schleife. Diese Schleife wird so oft durchlaufen, wie die Bedingung True ergibt. Pro Durchlauf wird der folgende Anweisungsblock einmal durchlaufen. Erst dann wird das Ergebnis erneut gestet. Liefert die Bedingung nunmehr False, bricht die Schleife ab.

Programmverlauf einer Schleife

Syntax 

while(Bedingung)
{
  // Anweisungen
}

Im folgenden Beispiel wird eine einfache Variable initialisiert. Die Schleife wird nun so oft durchlaufen, wie die Variable kleiner als zehn ist. Um sicherzustellen, dass die Schleife nicht zu einer endlosen Ausgabe führt, wird die Variable im Anweisungsblock inkrementiert.

Quellcode 

public class MyClass
{
  public static void main(String[] args)
  {
    int i = 0;
		
    while(i<10)
    {
      System.out.print(i);
      i++;
    }    
  }
}
Ausgabe 

012345789

» Do While nach oben «

Die Do - While - Schleife ist eine weitere Variante der While - Schleife, die sich jedoch nur durch ein kleines Detail im Programmverlauf und in der Syntax abweicht. Der Unterschied zum Original besteht darin, dass der Code der Schleife mindestens einmal ausgeführt wird, bevor die eigentliche Bedingung die Prüfung zum ersten mal durchführt.

Programmverlauf einer Schleife

Syntax 

do
{
  // Anweisungen
}
while(Bedingung);

Das folgende Beispiel soll dies verdeutlichen. Zu beachten ist die Syntax der Anweisung. Sie setzt sich zusätzlich aus dem Do - Befehl zusammen. Obwohl unsere Variable als False definiert ist, wird unsere Schleife mindestens einmal ausgeführt.

Quellcode 

public class MyClass
{
  public static void main(String[] args)
  {
    boolean b = false;
		 
    do
    {
      System.out.print("ProgrammersBase.NET");
    }
    while(b);    
  }
}
Ausgabe 

ProgrammersBase.NET

» For nach oben «

Die sogenannte For - Schleife ist die wichtigste und flexibelste Schleife ihrer Art. Gegenüber anderen Schleifen setzt sie sich aus drei Parametern zusammen. Diese erlauben in ebenso vielen Schritten das Anlegen von Variablen, deren Test in Form einer Bedingung und die nötigen Manipulationen.

Im ersten Schritt werden alle Variablen erzeugt, was jedoch nur einmalig beim Eintritt in die Schleife geschieht. Danach wird die eigentlich Bedingung getestet und in Abhängigkeit deren Ergebnis der Anweisungsbock ausgeführt. Letztlich werden alle Variablen inkrementiert beziehungsweise dekrementiert. Diese Prozedur wird so oft durchlaufen, wie die Bedingung True ergibt.

Syntax 

for(Typ Variable = Wert; Bedingung; Update)
{
  // Anweisungen
}

Hier ein praktisches Beispiel einer For - Schleife.

Quellcode 

public class MyClass
{
  public static void main(String[] args)
  {
    for(int i=0; i<10; i++)
      System.out.print(i);  
  }
}
Ausgabe 

012345789

» Break und Continue nach oben «

In Java gibt es zwei Möglichkeiten, den Verlauf einer Schleifenanweisung zu steuern. Dafür stehen zwei Anweisungen zur Verfügung.

Die Break - Anweisung bricht die aktuelle Schleife ab, während die Continue - Anweisung einen neuen Durchlauf einleitet. Sind die Schleifen ineinander verschachtelt, so bezieht sich die Anweisung immer auf die innere Schleife. Bei einem Abbruch wird dann direkt mit der nächsten Anweisung nach der Schleife fortgefahren.

break; Abbruch der Schleife
continue;Wiederholung der Schleife

Das folgende Beispiel nutzt eine For - Schleife, die allerdings keine Bedingung enthält. Diese wird in einer separaten Bedingung geprüft, die durch die Break - Anweisung die Schleife gegebenenfalls verlässt.

Quellcode 

public class MyClass
{
  public static void main(String[] args)
  {
    for(int i=0; ;i++)
    {
      System.out.print(i);
      
      if(i==9)
        break;
    }    
  }
}
Ausgabe 

0123456789

Ebenso wollen wir kurz die Continue - Anweisung praktisch anwenden. Folglich iterieren wir durch alle Elemente eines Arrays, bis wir die sechste Position erreicht haben. An dieser Stelle wird nicht die Continue - Anweisung ausgeführt, sondern unsere Meldung.

Quellcode 

public class MyClass
{
  public static void main(String[] args)
  {
    int[] a = {0,1,2,3,4,5,6,7,8,9};

    for(int i=0;i<10;i++)
    {
      if(a[i] != 6)
        continue;
      else
        System.out.print("Position "+i);
    }   
  }
}
Ausgabe 

Position 6

Letztlich möchten wir Ihnen eine weitere Variante einer Sprunganweisung vorstellen. Sie arbeitet mit einem festen Label, sprich einer Markierung, die später im Programmverlauf wieder angesprungen werden kann.

Die Syntax ist recht einfach. Das Label wird durch einen Bezeichner und einen Doppelpunkt benannt. Später kann über eine modifizierte Anwendung der Break - Anweisung das Label wieder angesprungen werden.

Syntax 

Label:
break Label;

Das folgende Beispiel definiert eine boolesche Variable, die wir dann ausgeben lassen. Wichtig ist, dass das Label unmittelbar vor der Schleife steht. Nachdem der Wert ausgegeben wird, verzweigen wir wieder vor die Schleife. Zu beachten ist, dass diese nicht noch einmal durchgeführt wird, sondern nach der Schleife fortgesetzt wird.

Quellcode 

public class MyClass
{
  public static void main(String[] args)
  {
    boolean b = true;
		
    label:
    if(b)		
    {		 		
      System.out.print(b);
      break label;
    }    
  }
}
Ausgabe 

true

Natürlich hätte das obige Beispiel auch ohne Label die gleiche Ausgabe gebracht. An dieser Stelle raten wir ohnehin von der Nutzung dieses Kozepts ab, da es als veraltet und fehleranfällig gilt.


» Endlosschleifen nach oben «

Dieses Kapitel möchten wir mit einigen Hinweisen abschließen. Wir wir gesehen haben, basieren alle Schleifen auf der Auswertung einer Bedingung. Diese Stellen müssen gut durchdacht werden, denn es ist durchaus möglich, eine Schleife zu programmieren, deren Bedingung immer True ergibt.

Je nach Aufgabe dieser Schleife kann das zu verherenden Schäden folgen, denn diese wird das Programm permanent blockieren, da sie alle ihre Anweisungen unendlich oft ausführt. Auch wenn viele Compiler bereits diverse dieser Fehlerquellen erkennen können, so gibt es dennoch keinen hundertprozentigen Schutz gegen diese Art der Fehlerquellen.


« Kapitel Kapitelübersicht nach oben Kapitel »