11.2 Beispiele (if-else)
 
if-else Die Syntax einer Verzweigung in Java hat folgende Gestalt:

if(<Bedingung>){
   <Anweisung 1>
   <Anweisung 2>
   ...
   <Anweisung n>
}
else {
   <Anweisung 1>
   <Anweisung 2>
   ...
   <Anweisung m>
}

Dabei kann <Bedingung> direkt ein boolscher Wert (true oder false) sein oder aber ein Ausdruck, der zu einem boolschen Ausdruck ausgewertet wird.
 

Beispiel 1 Wir stellen uns vor, dass eine Turlte das links dargestellte Bild erzeugt und zwar auf folgendem Wege. Sie startet am unteren linken unteren (Süd-West) Punkt und zeichnet bei jedem Klick auf den zeichne!-Schalter eine weitere Seite des Sechsecks. Die Farbe soll dann automatisch umspringen.  Wenn man ein mal die Richtungen der Turtle anschaut, und wenn man weiß, dass der Orientierungswinkel der Turtle als Winkel zur einer gedachten Rechtsachse im mathematisch positiven Sinne gemessen wird, ist es nicht sehr schwer zu erkenne, dass die Spur der Turtle rot gefärbt wird, wenn dieser Winkel größer also 1800 misst.
 
Download:
Verzweigung.java
public void zeichne() {
  if (t1.getOrientation()>180){
    t1.setColor(Color.RED);
  }
  else{
    t1.setColor(Color.BLUE);
  }
  t1.forward(40);
  t1.right(60);
}
Passiert oft, ist aber für Anfänger nicht zu empfehlen Wenn der Anweisungsblock, wie in unserem Beispiel aus nur einer Anweisung besteht, kann man die Blockklammern weglassen.

public void zeichne() {
  if (t1.getOrientation()>180)
    t1.setColor(Color.RED);
  else
    t1.setColor(Color.BLUE);
  t1.forward(40);
  t1.right(60);
}
 

  Das Einrücken ist dringend zu empfehlen, um auch optisch deutlich zu machen, was zu einem Verzweigungsblock gehört und was nicht.
   
Beispiel 2
das Ulam-Spiel
Das Ulam-Spiel hat folgende Spielregeln:

Wählen Sie eine Zahl und führen Sie den folgenden Algorithmus durch:

Wiederhole
     wenn Zahl gerade dann halbiere sie
     sonst nimm sie mal 3 und füge 1 hinzu

Nehmen wir als Startwert 3, so ergibt sich folgende Folge:

3 - 10 - 5 - 16 - 8 - 4 - 2 - 1 - 4 - 2 - 1 - 4 - 2 - 1....

Eigentlich können wir bei 1 aufhören, da sich danach die Zahlen 4 - 2 - 1 immer wieder wiederholen.

Für die Startzahl 23 erhalten wir die Zahlenfolge:

23 - 70 - 35 - 106 - 53 - 160 - 80 - 40 - 20 - 10 - 5 - 16 - 8 - 4 - 2 - 1

Das eigenartige an diesen nach unserer Spielregel erzeugten Zahlenfolge ist, dass sie Zahlen liefert, die mal größer mal kleiner sind, ohne dass eine Regel für das Auf und Ab gefunden werden könnte. Auch dass alle bekannten Folgen irgendwann auf die 1 stoßen wirkt überraschend. Für die Vermutungen, dieser Zahlenfolgen betreffend hat man bis heute noch keinen mathematischen Beweis gefunden.  Man hat diesen Zahlenfolgen deshalb auch einen Namen gegeben. Sie heißen Ulam-Folgen. Was ist nahe liegender, als die Zahlen von Ulamfolge durch ein Programm errechnen zu lassen.

Der eigentliche Algorithmus ist nicht sehr schwer:

if (i % 2 ==0){
  i = i/2;
}
else{
  i = i*3+1;
}
  Man muss nur wissen, dass i % 2 den Rest der Division von i durch 2 liefert. In den runden Klammern hinter dem Wort if wird also geprüft, ob der Rest bei der Division 0, die Zahl i also gerade ist. Der Ausdruck i = i/2 dividiert den aktuellen Wert von i durch 2 und speichert diesen neuen Wert wieder in der Variablen i. Entsprechendes gilt für i = i*3+1.

Da wir davon ausgehen, dass die Folge über kurz oder lang bei der 1 landet und wir dann die Berechnungen abbrechen wollen, fügen wir unseren Quelltext in eine while-Schleife, deren Schleifenkörper solange immer wieder abgearbeitet wird, solange i nicht 1 ist:

while (i !=1){
  if (i % 2 ==0){
    i = i/2;
  }
  else{
    i = i*3+1;
  }
}

Nun sollten wir die errechneten Zahlen unserer Ulamfolge auch grafisch darstellen. Wir wollen dies so tun, dass eine Turtle schmale Balken (Striche) zeichnet, deren Längen gerade die Zahlen darstellen.
Dazu setzen wir unsere Turtle in die linke untere Ecke (-190/-190) und hat die Blickrichtung, wie gewöhnlich nach Norden. Mit
forward(i) zeichnet sie einen Strich der Länge i. Jetzt springt sie auf die Position ( -188/-190), um dort den nächsten Strich zu malen. Die Positionen der Turtle verwalten wir in den Variabeln xStart und yStart.  Der Schleifenkörper wird also um das Steuern der Turtle und dem Zeichnen ergänzt, das ganze Programm hat schließlich das nachfolgende Aussehen.
 

Download:
Ulam.java
 
import turtle.*;
import java.awt.*;

public class Ulam extends TurtleFrame {
  Turtle t1;
 
int i=23; //Startwert
  double xStart = -190; //Startposition
  double yStart = -190;
  
  public Ulam(String title) {
    super(title);
    t1 = new Turtle(tWin); //t1 wird erzeugt
    t1.jumpTo(xStart,yStart);// t1 nimmt Startposition ein
  }

  public void zeichne() {
    while (i !=1){
      if (i % 2 ==0){
        i = i/2;
      }
      else{
        i = i*3+1;
      }
      t1.forward(i); //Zeichnet i-Pixel langen Balken
     
xStart = xStart+2; //x-Wert der nächsten Position
      t1.jumpTo(xStart,yStart); //t1 nimmt neue Position ein
    }
  }

  public static void main (String[] args) {
    new Ulam("Ulam-Folge");
  }
}
   
zu 11.3 Chaosspiel
zur Startseite www.pohlig.de  (C) MPohlig 2004