Skip to main content

Nutze das Java Switch Case Statement für komplexe Verzweigungen

Java switch case statement – was ist das?
Wozu brauchst du das?

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.

Wie hat dir dieser Beitrag gefallen?
Vielleicht hast du Lust einen Kommentar zu hinterlassen.
Na dann, schreibe doch einen Kommentar unter diesen Beitrag.


Ähnliche Beiträge

So organisierst und verwaltest du ganz bequem deine Java Projekte

Du kennst das auch. Denn du bist ja fleißig. Und weil du so fleißig bist, hast du mitunter auch mehrere Java Projekte gleichzeitig laufen. Und dann kommt es vor, dass du enorm viele Java Projekte am Laufen hast. Und dein Package-Explorer wird extrem unübersichtlich. In diesem Beitrag möchte ich dir zwei Varianten vorstellen, wie du […]

So kannst du zweidimensionale Java Arrays anlegen und nutzen

Java Arrays zweidimensional

Eines der bedeutendsten Instrumente in der Mathematik ist das Koordinatensystem. Die gedankliche Grundlage dieses Werkzeuges lieferte der französische Naturwissenschaftler und Philosoph Rene Descartes. Man muss sich einmal verdeutlichen, was dies für die damalige Zeit bedeutete. Bisher wurden mathematische Probleme lediglich durch Berechnungen gelöst. Denke an geometrische Figuren, wie Dreiecke und Vierecke. Der Umfang wurde lediglich […]

So implementierst du Instanzmethoden in deine Java Klasse

Java Instanzmethoden

In einen der letzten Beiträge habe ich dir gezeigt, wie du eine Klasse anlegen kannst. Ich habe die Klasse „Mensch“ oder „Human“ angelegt und wir haben die erste Instanzvariable implementiert. Dein Code sollte jetzt so aussehen: public class Human { int size=156;//size in centimeter } In diesem Beitrag werde ich dir zeigen, wie du Java […]

Java Übung 16 – Bestimme den größten gemeinsamen Teiler

Java Übung Teiler

In dieser Java Übung möchte ich, dass du den größten gemeinsamen Teiler zwei Zahlen ermittelst. Ich möchte, dass du das Ganze mit einer while-Schleife umsetzt. Und wie? Du legst eine neue Klasse „GGT“ (größter gemeinsamer Teiler) an. In diese Klasse implementierst du eine Klassenmethode „berechneGGT“. Diese erwartet zwei Argumente vom Datentyp Integer.

Java Exklusives Oder – So nutzt du den Xor Operator

Java exklusives oder

In diesem Beitrag möchte ich dir den Xor Operator von Java vorstellen. Dieser Operator wird auch als ausschließendes oder exklusives Oder bezeichnet. Ein Beispiel: Was wilst du heute zum Mittag essen: Fleisch oder Fisch? Auf diese Frage gibt es nur eine Antwort. Es ist entweder Fisch oder Fleisch. Niemals beides. Das Eine schließt das andere […]

Java Übung: Alles beginnt mit Hello World

Java Übung Hello World

Alles beginnt mit „Hello World“. Sämtliche Java Bücher beginnen mit diesem ersten Beispiel. Auch die Java Übungen sollen mit diesem ersten Programm starten. Definiere eine Klasse „Hello World“. Implementiere die Main Methode. Die Main Methode soll bei Programmaufruf die Bildschirmanzeige „Hallo Welt“ zurückgeben. Die Lösung zur Java Übung „Hallo Welt“ public class HelloWorld{ public static […]

So nutzt du Methoden aus der Java String Klasse

Java Strings Methoden

In einen der letzten Beiträge haben wir darüber gesprochen, dass Java Strings – Objekte sind. Dass Strings in allen Programmen äußerst häufig vorkommen Und dass sich deshalb Referenzvariablen String-Objekte im String Pool teilen. Das Konzept hinter dem String-Pool ist die Teilung der Ressourcen. Und das bedeutet: Weniger Objekte – mehr Speicher Mehr Speicher – bessere […]