So kannst du das Switch Case Statement in Java Programmen nutzen

Lass mich anders beginnen…
In einen meiner früheren Beiträge habe ich schon einmal über bedingte Anweisungen oder Zuweisungen geschrieben.

Diese if und else Konstrukte funktionieren eigentlich ganz gut.
Aber was ist, wenn du mehrere Parameter abfangen möchtest.

Okay ein Beispiel…

Wie ist es in einer Schule?
Die Sommerferien sind gerade vorbei und alle Kinder gehen wieder in die Schule.
Die Kinder werden ihrem Alter entsprechend, in gewissen Klassenstufen eingeteilt.

Ein Kind, welches sechs Jahre alt ist, ist demnach in der ersten Klasse.
Ein siebenjähriges Kind wäre demnach in der zweiten Klasse usw.

Außerdem findet eine Unterteilung in Jungen und Mädchen statt.
Du hast in einem solchen Programm somit zwei Kriterien, welche untersucht werden.

Mit einer if else Bedingung würde dein Java Code in etwa so aussehen.

public class SwitchCase {

	static void weiseKlasseZu(int alter, String geschlecht) {
		if (alter == 6 && geschlecht.equals("m")) {
			System.out.println("Kind ist in der ersten Klasse");
			System.out.println("Kind ist männlich");
		} else if (alter == 6 && geschlecht.equals("w")) {
			System.out.println("Kind ist in der ersten Klasse");
			System.out.println("Kind ist weiblich");
		} else if (alter == 7 && geschlecht.equals("m")) {
			System.out.println("Kind ist in der zweiten Klasse");
			System.out.println("Kind ist männlich");
		} else if (alter == 7 && geschlecht.equals("w")) {
			System.out.println("Kind ist in der ersten Klasse");
			System.out.println("Kind ist weiblich");
		} else if (alter == 8 && geschlecht.equals("m")) {
			System.out.println("Kind ist in der dritten Klasse");
			System.out.println("Kind ist männlich");
		} else if (alter == 8 && geschlecht.equals("w")) {
			System.out.println("Kind ist in der dritten Klasse");
			System.out.println("Kind ist weiblich");
		} else if (alter == 9 && geschlecht.equals("m")) {
			System.out.println("Kind ist in der vierten Klasse");
			System.out.println("Kind ist männlich");
		} else if (alter == 9 && geschlecht.equals("w")) {
			System.out.println("Kind ist in der vierten Klasse");
			System.out.println("Kind ist weiblich");
		} else {
			System.out.println("Kind ist nicht in der Schule");
		}
	}

	public static void main(String[] args) {
		weiseKlasseZu(6, "m");
	}
}

Ganz kurz.
Die Methode prüft die Argumente, welche ihr übergeben wurden.
Dann springt die Methode in den entsprechenden if, if-else oder else Block und führt diesen aus.

Du siehst selbst, dass diese if else Verzweigungen irgendwann äußerst kompliziert werden.
Und bis dato haben wir lediglich zwei Argumente.

Stell dir vor du lässt drei Argumente untersuchen.
Die else if Verzweigungen werden irgendwann so komplex, dass da kein Schwein mehr durchblickt…

Ich möchte dir in diesem Beitrag eine andere Möglichkeit vorstellen, um bedingte Anweisungen auszuführen.

Das Ganze nennt sich switch case oder auch switch statement.

Lass uns mal ein Java Argument switchen.

Und so geht’s.

Für dieses Schulprogramm würde der Java Code dann so aussehen.

public class SwitchCase {
 
static void switcheWerte(int alter) {
switch (alter) { //Parameter, welcher geswitcht wird
case 6: //im Falle dass der Parameter 6 hakt die Methode hier ein
System.out.println("kind ist in der ersten Klasse");
}
}
 
 
public static void main(String[] args) {
switcheWerte(8);
}
}

Ich habe eine Methode, namens „switcheWerte“ implementiert.
Diese Methode ist statisch.
Das hat den Vorteil, dass ich zum Programmstart kein Objekt erzeugen muss.

Und diese Methode erwartet beim Aufruf einen Parameter vom Datentyp Integer.
Ich übergebe ihr also den Wert 6.

Innerhalb der Methode siehst du ein neues Java Keyword – switch.
Dieses Keywort leitet den switch ein.
Danach muss ich dem Programm den Parameter geben, welcher geswitcht werden soll.

In diesem Fall lass ich das Alter switchen.
Der Parameter steht in Klammern

Okay und dann beginnt der Codeblock zur Switch Anweisung.

• Also Klammer auf.
• Dann folgt das Keyword case.
  Falls der übergebene Parameter diesem Case entspricht – also sechs ist- wird die nachfolgende Anweisung ausgeführt.

So jetzt kannst du dein Programm einmal starten.

Wenn du der Methode den Parameter sechs übergibst, funktioniert es.
Wenn du einen anderen Parameter, beispielsweise 7 übergibst, passiert nichts.

Ist doch klar.
Du hast bis dato noch kein Case-Fall für die 7 vereinbart.

Also los.
Du kannst jetzt für jedes Alter (7-16 oder älter) so einen Case schreiben.
Der Java Code würde dann so aussehen:

public class SwitchCase {
 
static void switcheWerte(int alter) {
switch (alter) {
case 6: 
System.out.println("kind ist in der ersten Klasse");
case 7:
System.out.println("kind ist in der zweiten Klasse");
case 8:
System.out.println("kind ist in der dritten Klasse");
case 9:
System.out.println("kind ist in der vierten Klasse");
case 10:
System.out.println("kind ist in der fünften Klasse");
case 11:
System.out.println("kind ist in der sechsten Klasse");
case 12:
System.out.println("kind ist in der siebenten Klasse");
case 13:
System.out.println("kind ist in der achten Klasse");
case 14:
System.out.println("kind ist in der neuenten Klasse");
case 15:
System.out.println("kind ist in der zehnten Klasse");
}
}
 
 
public static void main(String[] args) {
switcheWerte(7);
}
}

Für jedes Szenario (Alter) vereinbarst du eine separate Anweisung.
Dann übergibst du der Methode einen Wert, in diesem Fall 7 und los geht‘s.

Die Java Methode prüft dann das Argument und hakt genau in den case ein, welcher übereinstimmt.

Also klicke auf „Run“ und schau was passiert.

Na… und. Mist….
Die Methode hakt zwar bei der 7 ein, aber führt nicht nur die Anweisung für den case 7 aus.
Sondern alle nachfolgenden ebenfalls.

Und das ist blöd.

Wir müssen also die Methode erweitern.
Immer wenn eine Methode nach einer bestimmten Anweisung abrechen soll, benötigst du das Java Keywort break.
Also muss nach jedem Case die break-Anweisung folgen.

public class SwitchCase {
 
static void switcheWerte(int alter) {
switch (alter) {
case 6: 
System.out.println("kind ist in der ersten Klasse");
break; // Das Java Keywort break bewirkt den Absprung aus der Methode
case 7:
System.out.println("kind ist in der zweiten Klasse");
break;
case 8:
System.out.println("kind ist in der dritten Klasse");
break;
case 9:
System.out.println("kind ist in der vierten Klasse");
break;
case 10:
System.out.println("kind ist in der fünften Klasse");
break;
case 11:
System.out.println("kind ist in der sechsten Klasse");
break;
case 12:
System.out.println("kind ist in der siebenten Klasse");
break;
case 13:
System.out.println("kind ist in der achten Klasse");
break;
case 14:
System.out.println("kind ist in der neuenten Klasse");
break;
case 15:
System.out.println("kind ist in der zehnten Klasse");
break;
}
}
 
 
public static void main(String[] args) {
switcheWerte(7);
}
}

Und jetzt funktioniert das Java Programm auch, wie es soll.
Du kannst jetzt für die Zahlen 6 bis 15 unterschiedliche Anweisungen ausführen lassen.

Aber was ist mit Werten außerhalb des Bereiches?
Also zum Beispiel 5 oder 16?
Dafür vereinbarst du einen default case.
Und dieser default-case fängt alle Werte ab, welche nicht in diesem Case Szenario vorkommen.

Und so schreibst du den Java Code mit default-Werten.

public class SwitchCase {
 
static void switcheWerte(int alter) {
switch (alter) {
case 6:
System.out.println("kind ist in der ersten Klasse");
break; 
case 7:
System.out.println("kind ist in der zweiten Klasse");
break;
default: //Default Werte werden abgefangen
System.out.println("Kind ist nicht in der Schule");
break;
case 8:
System.out.println("kind ist in der dritten Klasse");
break;
case 9:
System.out.println("kind ist in der vierten Klasse");
break;
case 10:
System.out.println("kind ist in der fünften Klasse");
break;
case 11:
System.out.println("kind ist in der sechsten Klasse");
break;
case 12:
System.out.println("kind ist in der siebenten Klasse");
break;
case 13:
System.out.println("kind ist in der achten Klasse");
break;
case 14:
System.out.println("kind ist in der neuenten Klasse");
break;
case 15:
System.out.println("kind ist in der zehnten Klasse");
break;
}
}
 
public static void main(String[] args) {
switcheWerte(17);
}
}

Ich habe ganz bewusst den default-Case nicht zum Schluss eingesetzt.
Du kannst nämlich jeden Case irgendwo einsetzen.
Beispielsweise kannst du mit 8 beginnen und mit 1 enden.

Das spielt keine Rolle.

• Java sucht sich in der kompletten Liste den entsprechenden Case.
• Hakt dort ein.
• Führt die Anweisung aus.
• Und springt durch das Keywort break wieder aus dem Case.

Und?
Ist doch ne coole Sache, oder?

Ich denke, dass dieses switch case Statement besser, leichter und intuitiver ist, als tausende if else Verzweigungen.

Aber wir haben bis jetzt nur ein Argument.
Was ist, wenn wir noch das Geschlecht der Kinder auswerten lassen wollen?

Na hast du Lust das Ganze noch ein bisschen zu erweitern?

Na dann los?

So kannst du weitere Verzweigungen in die case Anweisungen einbauen.

Eigentlich ist es ganz einfach.

Für jeden case kannst du dann wieder eine bedingte Anweisung ausführen lassen.

Implementieren wir doch einen zweiten Parameter (Geschlecht) in die Methode.
Und dann lassen wir in jedem case eine bedingte Anweisung durchlaufen.

Für die ersten beiden Cases würde der Java Code so aussehen:

public class SwitchCase {

	/*
	 * Methode erwartet jetzt zwei Parameter
	 */
	static void switcheWerte(int alter, String geschlecht) {
		switch (alter) {
		case 6:
			if (geschlecht.equals("m")) {
				System.out.println("Kind ist männlich");
				System.out.println("kind ist in der ersten Klasse");
			} else {
				System.out.println("Kind ist weiblich");
				System.out.println("kind ist in der ersten Klasse");
			}
			break;
		case 7:
			if (geschlecht.equals("m")) {
				System.out.println("Kind ist männlich");
				System.out.println("kind ist in der zweiten Klasse");
			} else {
				System.out.println("Kind ist weiblich");
				System.out.println("kind ist in der zweiten Klasse");
			}
			break;
		default: // Default Werte werden abgefangen
			System.out.println("Kind ist nicht in der Schule");
			break;
		}
	}

	public static void main(String[] args) {
		switcheWerte(7, "w");// Zwei Parameter beim Aufruf
	}
}

Aber da geht noch mehr…

Den Java switch case Block mit zweiten switch Wert erweitern.

Ab Java 7 kannst du auch String-Werte switchen.

Da das Geschlecht in unserem Beispiel ein solcher String-Wert ist, bietet es sich an, diesen zu switchen.

Also los…

1. Im case-Block 6 einen zweiten switch Wert vereinbaren.
2. Dann einen „Unter Case“ für männlich implementieren.
   Und die entsprechenden Anweisungen hineinsetzen.
3. Das Keywort break nicht vergessen.

Und im zweiten Case-Block gehst du analog vor und fängst die weiblichen Geschlechter ab.

Und so würde der Java Code für die Altersklassen 6 und 7 aussehen.

public class SwitchCase {

	static void switcheWerte(int alter, String geschlecht) {
		switch (alter) {
		case 6:
			switch (geschlecht) {
			case "m":
				System.out.println("Kind ist männlich");
				System.out.println("kind ist in der ersten Klasse");
				break; //case m break
			case "w":
				System.out.println("Kind ist weiblich");
				System.out.println("kind ist in der ersten Klasse");
				break; //case w break
			}
			break; //case 6 break
		case 7:
			switch (geschlecht) {
			case "m":
				System.out.println("Kind ist männlich");
				System.out.println("kind ist in der zweiten Klasse");
				break;
			case "w":
				System.out.println("Kind ist weiblich");
				System.out.println("kind ist in der zweiten Klasse");
				break;
			}
			break;
		default: // Default Werte werden abgefangen
			System.out.println("Kind ist nicht in der Schule");
			break;
		}
	}
	
	
	public static void main(String[] args) {
		switcheWerte(8, "w");// Zwei Parameter beim Aufruf
	}
}

Zusammenfassung:

• Durch das switch statement kannst du Anweisungen an gewisse Bedingungen knüpfen.
• Du untersuchst also Werte und lässt abhängig vom jeweiligen Wert, Anweisungen ausführen.
• Das Java switch statement beginnt immer mit dem Java Keywort switch.
  Dann folgt in Klammern der Wert, welcher untersucht werden soll.
• Im Codeblock setzt du dann für jedes Szenario einen case ein.
  Java hakt dann in den entsprechenden Case ein und führt die Anweisungen zum case aus.
• Alle Werte welche nicht abgefangen werden können, werden dann im default case vereinbart.
• Wichtig ist das Java Keywort break.
  Dieses ist verantwortlich, aus der Anweisung heraus zu springen.
• Durch das Java switch case statement ist es möglich komplexe if else Anweisungen in einfacheren intuitiveren Java Code zu wandeln.