3 Ablaufsteuerung
3.1 Schleifen
3.1.1 Die for-Schleife
 
   
Kontroll-
strukturen

Sequenz
Iteration
Selektion
 		 Bisher bestanden unsere Programmierkünste darin, dass wir Befehl an Befehl reihten. Wir sagen auch, das Programm besteht aus einer Sequenz (oder Folge) von Befehlen oder Anweisungen. Diese können Zuweisungen oder Methodenaufrufe sein. Jede Programmiersprache verfügt neben der Sequenz über weitere Möglichkeiten den ABlauf eines Programms zu steuern, den sog. Kontrollstrukturen. Dazu zählen Schleifen (auch Iteration genannt) und Verzweigung (auch Selektion genannt). In diesem Kapitel wollen wir lernen, wie man in Java Schleifen realisiert. Drei Techniken stehen uns zur Verfügung: die for-schleife, die do-while-Schleife und die while-Schleife. Im Prinzip sind diese Techniken gleichwertig, d.h. ein Problem das man mit einer Schleife lösen möchte kann man mit allen drei Techniken lösen. Die unterschiedlichen Techniken haben ihre spezifischen Vorzüge, so dass wir von Fall zu Fall entscheiden, mit welcher Technik wir den Vorzug geben. Wir beschäftigen uns zunächst mit der Vorschleife.
 
  Wir veranlassen die Turtle ein Sechseck zu zeichnen in dem wir in der zeichne()-Methode

public void zeichne(){
   t.forward(100);
   t.right(60);
}

eintragen, den Quelltext kompilieren und wenn das Programm läuft, sechsmal auf den  klicken. Das gleiche Ergebnis erhalten wir durch ein einmaliges Klicken des Zeichne!-Button, wenn wir die obige Sequenz versechsfachen zu:

public void zeichne(){
   t.forward(100);
   t.right(60);
   t.forward(100);
   t.right(60);
   t.forward(100);
   t.right(60);
   t.forward(100);
   t.right(60);
   t.forward(100);
   t.right(60);
   t.forward(100);
   t.right(60);
}

Dass diese Art nicht sehr befriedigend ist, muss nicht näher begründet werden. Eine echte Alternative ist die folgende zeichne()-Methode:

public void zeichne() {
  for(int i=1; i<=6; i++){
    t1.forward(100);
    t1.right(60);
  }
}
Struktogramm Vor Eintritt in die for-Schleife steht im Prinzip fest, wie oft das getan werden soll, was im Schleifenkörper steht, also das was sich zwischen den geschweiften Klammern im Quellkode der for-Schleife befindet. Die Vorwegkontrolle über den Schleifenkörper wird auch grafisch im sog.  Struktogramm der for-Schleife deutlich. Schauen wir uns die Syntax des Schleifenkopfes genauer an:
 
Download:
Sechseck.java		 for(int i=1; i<=6; i++){

}

Hinter dem reservierten Wort for steht zunächst eine runde Klammer, in der durch Semikola getrennt drei Ausdrücke stehen.

1. Ausdruck: int i=1

Es wird eine (Zähl)variable i deklariert und initialisiert. Auf diese Weise ist i lokal in der Schleife erklärt, außerhalb existiert diese Variable nicht mehr und kann erneut verwendet werden, ohne dass irgendwelche Konflikte auftreten. Ist dagegen die Variable i bereits deklariert, benötigt man hier nur noch eine Initialisierung (for i=1; i<=6; i++)), dann aber ist i nicht mehr lokal in der Schleife sondern in einem größeren Bereich definiert und Seiteneffekte müssen berücksichtigt werden. Wir empfehlen also, die oben dargestellte Variante.

3. Ausdruck: i++

Betrachten wir zunächst den dritten Ausdruck. In ihm wird i um 1 inkrementiert also sein Wert um 1 erhöht. Diese Inkrementierung findet am Ende eines jeden Schleifendurchgang statt.

2. Ausdruck: i <= 6

An zweiter Stelle steht ein Ausdruck, der zu 'wahr' oder 'falsch' ausgewertet wird. D.h. vor einem erneuten Schleifeneintritt wird geprüft, ob diese Bedingung noch wahr ist. Ist dies dies nämlich nicht oder nicht mehr der Fall, so wird die Schleife abgebrochen, der Schleifenkörper wird nicht mehr abgearbeitet. Ist die Bedingung von Anfang an 'falsch', dann wird der Schleifenkörper kein einziges Mal durchlaufen

Erwähnen müssen wir noch, dass der Wert i selbst im Schleifenkörper benutzt und unter Umständen neu gesetzt werden kann. Wir werden dazu später noch Beispiele kennen lernen.

 
zu 3.1.2 Die do-while-Schleife
zur Startseite www.pohlig.de  (C) MPohlig 2006