4.10.7 switch - Konstruktion
 
Reihung von if-Anweisungen Wie das Chaosspiel gezeigt hat, kann es vorkommen, dass man in einem Programmfluss an eine Stelle kommt, an der mehrerer Alternativen angeboten werden sollen. Konkret war es das Wählen einer der drei Eckpunkte. Diese Verzweigung kann man zwar mit drei ifs realisieren, es handelt sich aber genau genommen um eine Verzweigung zu drei Alternativen.

Allgemein:
 
 
.....
if(Bedingung 1) {
   //Anweisungsteil für Option 1
}
if(Bedingung 2) {
   //Anweisungsteil für Option 2
}
if(Bedingung 3) {
   //Anweisungsteil für Option 3
}
if(Bedingung 4) {
   //Anweisungsteil für Option 4
}
....

Die gewonnene Übersichtlichkeit erkauft man sich allerdings mit einem Nachteil. Er besteht darin, dass jede if-Anweisung ausgewertet werden muss, gleich ob eine vorausgegangene if-Anweisung schon "erfolgreich" war.

Eine Alternative bietet sich in einer switch-Konstruktion an:
 

Struktogramm

switsch int selektor;
selektor = .....//Initialisierung des Selektors

switch (selektor) {
   case 1  : //Anweisungen Option 1;
     break;
   case 2  : //Anweisungen Option 2;
     break;
   case 3  : //Anweisungen Option 3;
     break;
   case 4  : //Anweisungen Option 4;
     break;
   default ://was sonst passiert
}

Zur mehrseitigen Auswahl dient ein sog. Selektor, den wir der Einfachheit halber auch
selektor nennen. Er muss von einfachem Datentyp sein. wie char, byte, short oder int. Wir haben den "Typ int" gewählt, da die anderen uns noch unbekannt sind. Das reservierte Wort "switch" leitet die Selektion ein und die case-Anweisungen unterscheiden die verschiedenen Optionen. Hat der Selektor den Wert 3, so werden die Anweisungen der Option 3, also der Fall (=case) für den Selektorwert 3 ausgewertet.
 
  Wir schreiben unser Chaosspiel um und ersetzen die drei ifs durch eine switch-Anweisung. (Damit wir nicht so oft den Zeichne!-Button klicken müssen, wurde die Anzahl der Schleifendurchgänge pro Klick auf 1000 herhöht. Ferner haben wir zur Unterscheidung der drei Fälle der Turtle unterschiedliche Farben gegeben, Magenta für den ersten, Blau für den zweiten und Rot für den dritten Fall.
 
Download:
ChaosSpiel2.java
public void zeichne() {

    for(int i =0; i <1000; i++){
      zufall = (int)(3*Math.random())+1;
      switch(zufall){
        case 1:  schritt = Math.sqrt(Math.pow(xA-t1.getX(),2)
                            +Math.pow(yA-t1.getY(),2));
                 t1.turnTo(xA,yA);
                 t1.up();
                 t1.forward(0.5*schritt);
                 t1.down();
                 t1.setColor(Color.MAGENTA);
                 t1.writeTo(".",t1.getX(),t1.getY());
                 break;
        case 2:  schritt = Math.sqrt(Math.pow(xB-t1.getX(),2)
                            +Math.pow(yB-t1.getY(),2));
                 t1.turnTo(xB,yB);
                 t1.up();
                 t1.forward(0.5*schritt);
                 t1.down();
                 t1.setColor(Color.BLUE);
                 t1.writeTo(".",t1.getX(),t1.getY());
                 break;
        case 3:  schritt = Math.sqrt(Math.pow(xC-t1.getX(),2)
                            +Math.pow(yC-t1.getY(),2));
                 t1.turnTo(xC,yC);
                 t1.up();
                 t1.forward(0.5*schritt);
                 t1.down();
                 t1.setColor(Color.RED);
                 t1.writeTo(".",t1.getX(),t1.getY());
                 break;
        default : System.out.println("Error");
      }
   }
}
Detailiertere Analyse Die rot-markierten Klammern legen den switch-Block fest. Die case <..> sind tatsächlich Sprungmarken (Labels). Hat der Selektor s etwa den Wert s2, so springt das Programm an die Marke s2 und führt alle(!) Anweisungen im switch-Block ab der Marke s2 aus. Die mit case bezeichneten Stellen im Programm sind also keine Verzweigungen im eigentlichen Sinne, sondern lediglich Einstiegsmarkierungen. Damit ist aber die Funktionalität einer Mehrfachverzweigung nicht gegeben. Die schafft man erst, wenn man den switch-Block durch einen Sprung wieder verlässt. Mit den breaks realisiert man nun genau diese Sprünge.  
switch (s){ 
  case s1: Anweisung(1); 
           Anweisung(2); 
	   ......; 
           Anweisung(m); 
           break; 
  case s2: Anweisung(m+1); 
           Anweisung(m+2); ......; 
           Anweisung(n); 
           break; //Sprung aus dem Block 
  ........... 
  case sk: Anweisung(n+1); 
           Anweisung(n+2); 
           ........; 
           Anweisung(p); 
           break; 
  default: ...; 
           ...; 
           Anweisung(letzte); 
} 

Man beobachte, was mit dem Chaosspiel passiert, wenn wir die break-Anweisungen entfernen.
 

zu 4.10.8 Übungen
zur Startseite www.pohlig.de  (C) MPohlig 2004