Thema in Kurzform:
Benötigen wir eine Unterscheidung nach vielen Fällen, ist die beste Lösung oftmals die Verwendung eines switch-case-Statements. Diese Kontrollstruktur ist bei einem höheren Grad an Mehrfachverzweigung nicht zuletzt wegen der Übersichtlichkeit einer if bzw. else-if-Reihung vorzuziehen.
Um den switch-case-Mechanismus einzusetzen, müssen wir die beiden Schlüsselbegriffe switch und case wie im folgendem Beispiel verwenden:
char buchstabe = 'B';
switch(buchstabe){
case 'A':
System.out.println("Buchstabe ist A");
break;
case 'B':
System.out.println("Buchstabe ist B");
break;
case 'C':
System.out.println("Buchstabe ist C");
break;
case 'D':
System.out.println("Buchstabe ist D");
break;
}Wir erzeugen zunächst eine Testvariable buchstabe mit dem Wert 'B'. Diese übergeben wir nun in runden Klammern dem switch-Codeblock, wo der Wert der Variable nun als switch-Wert mit mehreren anderen Werten verglichen wird.
Jeder Vergleich wird mit dem Keyword case beschrieben. Man spricht deshalb auch von der "Fallunterscheidung". Entspricht der switch-Wert nun einem dieser Vergleichswerte, wird der dazugehörende Code ausgeführt.
In unserem Beispiel ist das zweite case ein Treffer und es erscheint auf der Konsole folgender Text:
Buchstabe ist B
Das Schlüsselwort break am Ende eines jeden case ist zwar optional, meistens jedoch notwendig, damit das Programm erwartungsgemäß funktioniert. Was bewirkt es? Steht am Ende eines case-Blocks ein break, wird die gesamte switch-case-Struktur sofort beendet. Das ist in der Regel so erwünscht.
Lassen wir die einzelnen break-Anweisungen aber weg, wird selbst nach einem Treffer die gesamte switch-case-Konstruktion bis zum Ende durchlaufen, was zumeist unnötiger Rechenaufwand ist. Das Auslassen von break hat außerdem zur Folge, dass nicht nur das case mit dem Treffer, sondern auch alle folgenden cases ausgeführt werden (jedenfalls solange ein break im Weg steht).
Was meinen Sie, printed der folgende Code?
int number = 1;
switch(number){
case 0:
System.out.println("0");
case 1:
System.out.println("1");
case 2:
System.out.println("2");
case 3:
System.out.println("3");
break;
case 4:
System.out.println("4");
}Da wir die Variable number mit dem Wert 1 in das switch-case schicken, erhalten wir bei case 1 einen Treffer. Da das break bei case 1 fehlt, läuft die Struktur auch die folgenden case 2 und case 3 durch. Erst case 3 hat am Ende das break, sodass die Kontrollstruktur erst jetzt beendet wird (case 4 wird damit nicht mehr ausgeführt). Auf der Konsole erscheint also:
1
2
3
Was passiert, wenn kein case einen Treffer liefert? Richtig: switch-case läuft bis zum Ende durch, wird beendet und es ist nichts geschehen.
Für den Fall, dass kein case dem switch-Wert entspricht, können wir mit default dafür sorgen, dass ein von uns geschriebener Standardcode ausgeführt wird. Zum Beispiel:
switch("Jupiter"){
case "Merkur":
System.out.println("Erster Planet");
break;
case "Venus":
System.out.println("Zweiter Planet");
break;
case "Erde":
System.out.println("Dritter Planet");
break;
case "Mars":
System.out.println("Vierter Planet");
break;
default:
System.out.println("Kein innerer Planet");
}Da dem switch-Wert "Jupiter" kein Vergleichswert der einzelnen cases entspricht, wird der Code von default ausgeführt.
Der default-Teil muss übrigens nicht am Ende stehen, sondern kann auch zwischen cases oder ganz am Anfang geschrieben sein.
Beim Einsatz von switch/case müssen wir insgesamt vier Regeln beachten. Verletzen wir auch nur eine davon, ist der Code Schrott.
1. Kompatible Datentypen: In einem switch/case-Statement sind nur bestimmte Datentypen sowie Wrapperklassen zulässig. Hier eine Übersicht der erlaubten (und underlaubten) Datentypen
| Datentyp | in switch/ case zulässig? |
|---|---|
| byte | ja |
| short | ja |
| char | ja |
| int | ja |
| String | ja |
| enums | ja |
| boolean | NEIN! |
| long | NEIN! |
| float | NEIN! |
| double | NEIN! |
Dies gilt auch für die entsprechenden Wrapper-Klassen. So ist der Einsatz der Klassen Byte, Short, Character, Integer erlaubt. Nicht möglich dagegen ist die Verwendung der Klassen Boolean, Long, Float und Double.
2. Alle cases müssen denselben oder einen kompatiblen Datentyp wie der switch-Wert haben.
3. Es darf keine doppelten cases geben!
4. Die case-Statements müssen entweder Literale oder Konstanten (final) sein. Es dürfen sonst keine Variablen als case verwendet werden.
Sehen wir uns hierzu ein Beispiel an:
int number = 10;
int number2 = 20;
final int number3 = 30;
switch(number){
case 50:
// Code
break;
case 199.99:
// Code
break;
case (number < 40):
// Code
break;
case 'A':
// Code
break;
case number2:
// Code
break;
case number3:
// Code
break;
}Mit dem ersten case (case 50:) ist alles in Ordnung.
Der zweite case allerdings verursacht schon einen Compiler-Fehler. Der Grund ist der double-Wert (199.99), was nicht zulässig ist.
Auch der dritte Case (number < 40) ist keine gute Idee! Ein boolescher Ausdruck kann niemals funktionieren.
Der char 'A' im vierten case ist voll in Ordnung (char und int sind voll kompatibel;'A' als int-Wert ist 65.)
Der nächste case (case number2:) haut auch nicht hin, was daran liegt, dass die Variable number2 keine unveränderliche Konstante (mit final deklariert) ist. Wenn wir schon unbedingt Variablen in einer switch-case-Kontrollstruktur anwenden wollen, dann läuft die Sache nur mit denen, die final sind. Das ist der Grund, warum number3 im letzten case einsetzbar ist.
Java Basics
[Java einrichten] [Variablen] [Primitive Datentypen] [Operatoren] [if else] [switch-case] [Arrays] [Schleifen]
Objektorientierung
[Einstieg] [Variablen ] [Konstruktor] [Methoden] [Rekursion] [Statische Member] [Initializer] [Pass-by-value] [Objektsammlungen] [Objektinteraktion] [Objekte löschen]
Klassenbibliothek
[Allgemeines] [String ] [Math] [Wrapper] [Scanner] [java.util.Arrays] [Date-Time-API]
Vererbung
[Einstieg Vererbung] [Konstruktoren bei Vererbung ] [Der protected Zugriffsmodifikator] [Abstrakte Klassen und Methoden] [Polymorphie in Java] [Typumwandlung] [Die Klasse Object] [Die toString()-Methode] [Objekte vergleichen] [Was ist ein Interface?]
