Switch Statements in Java

Wenn du viele Werte vergleichen musst, wird eine if-else-Kette schnell unuebersichtlich. Hier kommt switch ins Spiel — eine elegante Moeglichkeit, einen Wert gegen verschiedene Faelle zu pruefen. Und mit modernem Java (21+) wird switch richtig maechtig!

Das klassische Switch Statement

int tag = 3;

switch (tag) {
    case 1:
        System.out.println("Montag");
        break;
    case 2:
        System.out.println("Dienstag");
        break;
    case 3:
        System.out.println("Mittwoch");
        break;
    case 4:
        System.out.println("Donnerstag");
        break;
    case 5:
        System.out.println("Freitag");
        break;
    case 6:
        System.out.println("Samstag");
        break;
    case 7:
        System.out.println("Sonntag");
        break;
    default:
        System.out.println("Ungueltiger Tag!");
}

Ausgabe: Mittwoch

Aufbau

switch (ausdruck) {
    case wert1:
        // Code fuer wert1
        break;
    case wert2:
        // Code fuer wert2
        break;
    default:
        // Code, wenn kein case zutrifft
}

Wichtig: break nicht vergessen!

Ohne break faellt Java in den naechsten Case (“Fall-Through”):

int zahl = 2;

switch (zahl) {
    case 1:
        System.out.println("Eins");
    case 2:
        System.out.println("Zwei");
    case 3:
        System.out.println("Drei");
    default:
        System.out.println("Andere");
}

Ausgabe (ohne break!):

Zwei
Drei
Andere

Das ist meistens ein Bug — verwende daher immer break oder nutze die moderne Switch Expression.

Mehrere Cases zusammenfassen

int monat = 6;

switch (monat) {
    case 3: case 4: case 5:
        System.out.println("Fruehling");
        break;
    case 6: case 7: case 8:
        System.out.println("Sommer");
        break;
    case 9: case 10: case 11:
        System.out.println("Herbst");
        break;
    case 12: case 1: case 2:
        System.out.println("Winter");
        break;
    default:
        System.out.println("Ungueltiger Monat!");
}

Switch mit Strings

Seit Java 7 funktioniert switch auch mit Strings:

var sprache = "Java";

switch (sprache) {
    case "Java":
        System.out.println("Objektorientiert, statisch typisiert");
        break;
    case "Python":
        System.out.println("Dynamisch typisiert, einfache Syntax");
        break;
    case "JavaScript":
        System.out.println("Die Sprache des Browsers");
        break;
    default:
        System.out.println("Unbekannte Sprache: " + sprache);
}

Moderne Switch Expression (Java 14+)

Die Switch Expression ist die moderne Variante — kein break noetig, kein Fall-Through moeglich:

int tag = 3;

var tagName = switch (tag) {
    case 1 -> "Montag";
    case 2 -> "Dienstag";
    case 3 -> "Mittwoch";
    case 4 -> "Donnerstag";
    case 5 -> "Freitag";
    case 6 -> "Samstag";
    case 7 -> "Sonntag";
    default -> "Unbekannt";
};

System.out.println(tagName); // "Mittwoch"

Vorteile der Switch Expression

Klassisch	Modern
break noetig	Kein break noetig
Fall-Through moeglich	Kein Fall-Through
Kein Rueckgabewert	Kann Wert zurueckgeben
case X:	case X ->

Mehrere Werte pro Case

var monat = 6;

var jahreszeit = switch (monat) {
    case 3, 4, 5 -> "Fruehling";
    case 6, 7, 8 -> "Sommer";
    case 9, 10, 11 -> "Herbst";
    case 12, 1, 2 -> "Winter";
    default -> "Unbekannt";
};

System.out.println(jahreszeit); // "Sommer"

Mehrzeilige Cases mit yield

Wenn ein Case mehrere Anweisungen braucht, verwende yield:

var note = 2;

var bewertung = switch (note) {
    case 1 -> {
        System.out.println("Hervorragend!");
        yield "Sehr gut";
    }
    case 2 -> {
        System.out.println("Gut gemacht!");
        yield "Gut";
    }
    case 3 -> "Befriedigend";
    case 4 -> "Ausreichend";
    case 5 -> "Mangelhaft";
    case 6 -> "Ungenuegend";
    default -> "Ungueltig";
};

System.out.println("Bewertung: " + bewertung);

Pattern Matching in Switch (Java 21+)

Das ist die maechtigste Neuerung: Switch mit Typen und Mustern!

Typ-basiertes Switch

Object wert = 42;

var beschreibung = switch (wert) {
    case Integer i -> "Ganzzahl: " + i;
    case Double d -> "Dezimalzahl: " + d;
    case String s -> "Text: " + s;
    case null -> "null-Wert";
    default -> "Unbekannter Typ: " + wert.getClass();
};

System.out.println(beschreibung); // "Ganzzahl: 42"

Guarded Patterns (mit when)

Object wert = 42;

var ergebnis = switch (wert) {
    case Integer i when i > 100 -> "Grosse Zahl: " + i;
    case Integer i when i > 0 -> "Positive Zahl: " + i;
    case Integer i -> "Nicht-positive Zahl: " + i;
    case String s when s.isBlank() -> "Leerer String";
    case String s -> "Text: " + s;
    default -> "Anderer Typ";
};

Switch mit Sealed Classes

sealed interface Form permits Kreis, Rechteck, Dreieck {}
record Kreis(double radius) implements Form {}
record Rechteck(double breite, double hoehe) implements Form {}
record Dreieck(double basis, double hoehe) implements Form {}

double berechneFlaeche(Form form) {
    return switch (form) {
        case Kreis k -> Math.PI * k.radius() * k.radius();
        case Rechteck r -> r.breite() * r.hoehe();
        case Dreieck d -> 0.5 * d.basis() * d.hoehe();
    };
    // Kein default noetig, da sealed!
}

Vergleich: if-else vs. switch

Aspekt	if-else	switch
Bereiche (x > 10)	Ja	Nein (nur mit when in Java 21+)
Einzelne Werte	Ja, aber unuebersichtlich	Perfekt
Rueckgabewert	Nein (nur mit Variablen)	Ja (Switch Expression)
Fall-Through	Nicht moeglich	Moeglich (klassisch)
Pattern Matching	Nur instanceof	Voll unterstuetzt (Java 21+)

Wann was verwenden?

// if-else: Fuer Bereiche und komplexe Bedingungen
if (temperatur > 30) { ... }
else if (temperatur > 20) { ... }

// switch: Fuer einzelne Werte und Typen
var ergebnis = switch (sprache) {
    case "de" -> "Deutsch";
    case "en" -> "Englisch";
    default -> "Unbekannt";
};

Praktische Beispiele

Taschenrechner mit Switch Expression

import java.util.Scanner;

public class Rechner {
    public static void main(String[] args) {
        var scanner = new Scanner(System.in);

        System.out.print("Erste Zahl: ");
        var a = scanner.nextDouble();

        System.out.print("Operator (+, -, *, /): ");
        var op = scanner.next();

        System.out.print("Zweite Zahl: ");
        var b = scanner.nextDouble();

        var ergebnis = switch (op) {
            case "+" -> a + b;
            case "-" -> a - b;
            case "*" -> a * b;
            case "/" -> {
                if (b == 0) {
                    System.out.println("Division durch 0!");
                    yield Double.NaN;
                }
                yield a / b;
            }
            default -> {
                System.out.println("Unbekannter Operator: " + op);
                yield Double.NaN;
            }
        };

        System.out.printf("%.2f %s %.2f = %.2f%n", a, op, b, ergebnis);
        scanner.close();
    }
}

Wochentag-Infos

var tag = "Mittwoch";

var info = switch (tag) {
    case "Montag" -> "Wochenstart! Kaffee nicht vergessen.";
    case "Dienstag", "Mittwoch", "Donnerstag" -> "Mitten in der Woche.";
    case "Freitag" -> "Fast Wochenende!";
    case "Samstag", "Sonntag" -> "Wochenende! Entspann dich.";
    default -> "Kein gueltiger Wochentag.";
};

System.out.println(info);

Uebungen

Uebung 1: Monatstage

Schreibe ein Programm mit Switch Expression, das fuer einen gegebenen Monat (1-12) die Anzahl der Tage zurueckgibt (Februar = 28).

Uebung 2: Notenrechner

Schreibe ein Programm, das eine Schulnote (1-6) einliest und die Bewertung als Text ausgibt (1=“Sehr gut”, 2=“Gut”, etc.).

Uebung 3: Taschenrechner

Erweitere den Taschenrechner um die Operationen % (Modulo) und ^ (Potenz).

Uebung 4: Verkehrsmittel

Schreibe ein Switch mit Pattern Matching, das verschiedene Verkehrsmittel (als Records: Auto, Fahrrad, Zug mit jeweiligen Attributen) verarbeitet und die Reisezeit fuer 100 km berechnet.

Was kommt als Naechstes?

In der naechsten Lektion lernst du for-Schleifen — damit kannst du Code wiederholt ausfuehren, Bereiche durchlaufen und Collections verarbeiten.

Zusammenfassung

• Klassischer Switch braucht break und hat Fall-Through-Risiko
• Switch Expression (->) ist modern, sicher und kann Werte zurueckgeben
• Mehrere Cases mit Komma zusammenfassen: case 1, 2, 3 ->
• yield gibt Werte in mehrzeiligen Cases zurueck
• Pattern Matching (Java 21+) ermoeglicht Typ-basierte Switches mit when-Bedingungen
• Sealed Classes mit Switch brauchen kein default
• Verwende switch fuer einzelne Werte, if-else fuer Bereiche

---