Die Entscheidungsanweisung in Java

Wichtig für Smartphonebenutzer

Wir wollen im Beispiel Rechner den Umfang von verschiedenen Formen berechnen können. Dazu machen wir uns jetzt ein kleines Menü für das Konsolenfenster. Dafür können wir die if-Anweisung oder die switch-Anweisung verwenden, um einzelne Menüpunkte auswählen zu können.

Die if-Anweisug
Hier ist das ganze Beispiel:

1. import java.util.*;
3. public class Rechner {
5.         public static void main(String[] args) {
6.                
7.                 Scanner eingabe;
8.                 eingabe = new Scanner(System.in);
9.                
10.                 final double PI = 3.141592653589793D;
11.                 double a, b, c;
12.                                                
13.                 // Menü auf der Konsole ausgeben
14.                 System.out.println("1. Quadrat");
15.                 System.out.println("2. Rechteck");
16.                 System.out.println("3. Kreis");
17.                 System.out.println("-------------");
18.                 System.out.print(": ");
19.                
20.                 // Tastatureingabe abfangen
21.                 int menueEingabe = eingabe.nextInt();
22.                
23.                 System.out.println("-------------");
24.                
25.                 // Entscheidungsanweisung
26.                 if (menueEingabe == 1) {
27.                         // Abfrage der benötigten Werte
28.                         System.out.println("Umfangesberechnung 

     eines Quatrats");

29.                         System.out.print("Länge: ");
30.                         a = eingabe.nextDouble();
31.                         // Berechnung
32.                         c = a * 4;
33.                         System.out.println("-------------");
34.                         System.out.println("Der Umfange des 

     Quadrats beträgt: " + c);

35.                 }
36.                 else if (menueEingabe == 2) {
37.                         // Abfrage der benötigten Werte
38.                         System.out.println("Umfangesberechnung 
    
    

           eines Rechtecks");

39.                         System.out.print("Länge: ");
40.                         a = eingabe.nextDouble();
41.                         System.out.print("Breite: ");
42.                         b = eingabe.nextDouble();
43.                         // Berechnung
44.                         c = a * 2 + b * 2;
45.                         System.out.println("-------------");
46.                         System.out.println("Der Umfange des 

                            Rechtecks beträgt: " + c);

47.                 }
48.                 else if (menueEingabe == 3) {
49.                         double r;
50.                         // Abfrage der benötigten Werte
51.                         System.out.println("Umfangesberechnung 

                            eines Kreises");

52.                         System.out.print("Radius: ");
53.                         r = eingabe.nextDouble();
54.                         // Berechnung
55.                         c = r * 2 * PI;
56.                         System.out.println("-------------");
57.                         System.out.println("Der Umfange des 

     Kreises beträgt: " + c);

58.                 }
59.                 else {
60.                         // Ausgabe bei fehlerhafter Eingabe
61.                         System.out.println("Ungültige Eingabe!");
62.                 }
63.                
64.                 // Der Eingabestrom wird geschlossen. Es ist
65.                 // hier zwar nicht unbedingt notwendig, aber
66.                 // bei Eclipse wird sonst immer eine Warnung
67.                 // ausgegeben.
68.                 eingabe.close();
69.         }
71. }

Wie man sieht ist es schon einiges an Code, was da zusammenkommt. Gehen wir einfach mal alles der Reihe nach durch.

1. import java.util.*;

Wir teilen den Konstruktor mit dass wir das Paket java.util, wegen  der Tastatureingabe brauchen.

1. Scanner eingabe;
2. eingabe = new Scanner(System.in);

Hier erzeugen wir ein Objekt des Datentypen Scanner und fangen den Eingabestrom ab.

1. final double PI = 3.141592653589793D;

Mit final deklarieren wir unsere Konstante PI und initialisieren den Wert.

1. double a, b, c;

Hier deklarieren wir die Variablen a, b und c.

1. System.out.println("1. Quadrat");
2. System.out.println("2. Rechteck");
3. System.out.println("3. Kreis");
4. System.out.println("-------------");
5. System.out.print(": ");

Auf der Konsole wird unser Menü ausgegeben.

1. int menueEingabe = eingabe.nextInt();

In dieser Zeile wird eine Variable des Typs Integer (int) deklariert und der Eingabestrom wird als Integer mit der Methode nextInt() übergeben. Solange die Eingabe einen gültigen Wert hat, wenn nicht gibt der Kompiler eine Fehlermeldung zurück.

1. if (menueEingabe == 1) {
   
   

   // Abfrage der benötigten Werte

2.      ...
3. }
4. else if (menueEingabe == 2) {
5.      // Abfrage der benötigten Werte
6.      ...                   
7. }
8. else if (menueEingabe == 3) {
9.      double r;
10.      ...         
11. }
12. else {
13.      // Ausgabe bei fehlerhafter Eingabe
14.      System.out.println("Ungültige Eingabe!");
15. }

In Zeile 1 ist die erste if-Anweisung, die Anweisung zwischen ( und ) bezeichnet man als Ausdruck. Bei dem ausführen des Programmes wird erst der Ausdruck ausgewertet, dessen Ergebnistyp boolean sein muss. Hier im Beispiel wird verglichen ob die Variable menueEingabe gleich 1 ist, wenn ja (also true) werden die Anweisungen die in den folgenden beiden { und } (Block) steht ausgeführt und die beiden else if-Anweisung in Zeile 5 und 9 und die else-Anweisung in Zeile 13 werden nicht ausgewertet, natürlich werden auch nicht dessen Anweisungsblöcke ausgeführt.
Wenn der Ergebnistyp boolean false ist in der if-Anweisung in Zeile 1, wird der dazugehörige Anweisungsblock nicht ausgeführt und die else if-Anweisung in Zeile 5 wird ausgewertet. Ist dieser auch false wird die else if-Anweisung aus Zeile 9 ausgewertet. Wenn keine der Anweisungen true ergeben, wird die else-Anweisung in Zeile 13 ausgeführt.

Wenn der Anweisungsblock der if-, else if- und else-Anweisungen nur eine Anweisung enthält kann die { und } auch weggelassen werden. Hier ein Beispiel:

1. if (i == 1)
2.         System.out.println("Nur eine Anweisung für if");
3. else if (i == 6)
4.         System.out.println("Nur eine Anweisung für else if");
5. else
6.         System.out.println("Nur eine Anweisung für else");

Es ist auch möglich mit Logischen Operatoren mehrere Anweisungen zusammen im Ausdruck auszuwerten.
Hier ein Beispiel:

1. if (a == 0 && b == 0)
2.         ...

oder

1. if (a >= 0 || b <= 8)
2.         ...

Durch die Logischen Operatoren können auch beliebig viele Anweisungen im Ausdruck zusammen ausgewertet werden nicht nur zwei. Noch ein Beispiel:

1. if (b == true)
2.         ...

Die if-Anweisung wird ausgeführt wenn die Variable b true ist. es gibt eine verkürzte Schreibweise dafür:

1. if (b)
2.         ...

Wenn der Wert false erwartet werden soll, kann dafür der !-Operator (negiert b) verwendet werden:

1. if (!b)
2.         ...

Es ist Geschmackssache des Programmierers, ob er die normale oder die verkürzte Schreibweise verwendet.

Die switch-Anweisung
Hier ist der Teil der Entscheidungsanweisung, dieses Mal mit der switch-Anweisung:

1. // Entscheidungsanweisung
2. switch(menueEingabe) {
3.         case 1:
4.                 // Abfrage der Benötigten Werte
5.                 System.out.println("Umfangesberechnung eines 

   Quatrats");

6.                 System.out.print("Länge: ");
7.                 a = eingabe.nextDouble();
8.                 // Berechnung
9.                 c = a * 4;
10.                 System.out.println("-------------");
11.                 System.out.println("Der Umfange des Quadrats 

    beträgt: " + c);

12.                 break;
13.         case 2:
14.                 // Abfrage der Benötigten Werte
15.                 System.out.println("Umfangesberechnung eines 

    Rechtecks");

16.                 System.out.print("Länge: ");
17.                 a = eingabe.nextDouble();
18.                 System.out.print("Breite: ");
19.                 b = eingabe.nextDouble();
20.                 // Berechnung
21.                 c = a * 2 + b * 2;
22.                 System.out.println("-------------");
23.                 System.out.println("Der Umfange des Rechtecks 

    beträgt: " + c);

24.                 break;
25.         case 3:
26.                 double r;
27.                 // Abfrage der Benötigten Werte
28.                 System.out.println("Umfangesberechnung eines 

    Kreises");

29.                 System.out.print("Radius: ");
30.                 r = eingabe.nextDouble();
31.                 // Berechnung
32.                 c = r * 2 * PI;
33.                 System.out.println("-------------");
34.                 System.out.println("Der Umfange des Kreises 

    beträgt: " + c);

35.                 break;
36.         default:
37.                 // Ausgabe bei fehlerhafter Eingabe
38.                 System.out.println("Ungültige Eingabe!");
39. }

Jetzt zu der ersten Zeile:

1. switch(menueEingabe) {

In den ( und ) nach switch steht wieder unser Ausdruck. Hier ist des die Variable menueEngabe. Dann folgt ein Anweisungsblock der zwischen { und } steht.

1. case 1:

Nach dem Schlüsselwort case wird eine Konstante mit Doppelpunkt angegeben, jede case dass im Anweisungsblock von switch steht, ist eine Einsprungsmarke. Wenn also die Variable menueEingabe gleich 1 ist, werden ab dieser Einsprungsmarke die Anweisungen ausgeführt, bis zur nächsten break-Anweisung. Wenn die Variable nicht 1 ist, wird gleich zum nächsten case gegangen. Ist keines der case Konstanten zutreffen werden die Anweisungen die nach der default-Anweisung folgen ausgeführt.

1.  default:

2.  // Ausgabe bei fehlerhafter Eingabe

3.       System.out.println("Ungültige Eingabe!");

     
Nach dem default-Anweisung ist keine break-Anweisung mehr notwendig, weil die default-Anweisung das Ende der switch-Anweisung ist.

Hier noch ein kleine Beispiel:

1. switch(menueEingabe) {
2.         case 1:
3.                 System.out.println("Case 1");
4.         case 2:
5.                 System.out.println("Case 2");
6.                 break;
7.         case 3:
8.                 System.out.println("Case 3");  
9.                 break;
10.         default:
11.                 System.out.println("Default");
12. }

Wenn die Variable menueEingabe gleich 1 ist werden die Anweisungen von der Einsprungsmarke:

1. case 1:

und von

1. case 2:

ausgeführt. Warum das? Es ist ganz einfach, wenn keine break-Anweisung gefunden wir bis zur nächsten Einsprungsmarke werden deren Anweisungen auch noch mit ausgeführt bis auf eine break-Anweisung gestoßen wird. Es gibt Situationen bei dem dies beabsichtigt ist.