Java switch Statement: Cases, Fall-Through, and Arrow Syntax

What switch Is For

A switch compares one value against a list of fixed options and runs the branch that matches. When you find yourself writing a long if/else if chain that keeps testing the same variable against different constants, a switch says the same thing more clearly.

It only does equality checks against compile-time constants - it cannot test ranges or combine conditions. For those, stay with if/else.

The Classic switch Statement

The traditional form uses case labels with colons and a break after each branch:

public class Main {
    public static void main(String[] args) {
        int day = 3;

        switch (day) {
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday");
                break;
            default:
                System.out.println("Some other day");
        }
    }
}

Java evaluates day, jumps to the matching case, runs its statements, and the break exits the switch. The default branch runs when nothing else matches - think of it as the else. It is optional, but including it is good practice so unexpected values do not silently slip through.

The break Trap: Fall-Through

This is the single most common switch bug. If you leave out a break, execution does not stop at the end of a matching case - it falls through into the next case and keeps running until it hits a break or the closing brace:

public class Main {
    public static void main(String[] args) {
        int level = 1;

        switch (level) {
            case 1:
                System.out.println("Level 1");
                // no break - falls through!
            case 2:
                System.out.println("Level 2");
            case 3:
                System.out.println("Level 3");
                break;
        }
    }
}

You might expect just Level 1, but this prints all three lines. Because case 1 has no break, control slides straight into case 2 and case 3. Always add break unless you genuinely want fall-through - and when you do rely on it, leave a comment so the next reader knows it was on purpose.

Grouping Cases

Fall-through has one legitimate, tidy use: stacking case labels so several values share one block. Put the labels back to back with no code between them:

public class Main {
    public static void main(String[] args) {
        char grade = 'B';

        switch (grade) {
            case 'A':
            case 'B':
            case 'C':
                System.out.println("Pass");
                break;
            case 'D':
            case 'F':
                System.out.println("Fail");
                break;
            default:
                System.out.println("Unknown grade");
        }
    }
}

Here 'A', 'B', and 'C' all run the same "Pass" line. This is the intended way to say "any of these values does the same thing".

switching on Strings

You are not limited to numbers. Since Java 7 you can switch on a String, which is perfect for menu choices or command names:

public class Main {
    public static void main(String[] args) {
        String command = "stop";

        switch (command) {
            case "start":
                System.out.println("Starting...");
                break;
            case "stop":
                System.out.println("Stopping...");
                break;
            default:
                System.out.println("Unknown command: " + command);
        }
    }
}

Matching is case-sensitive - "Stop" would not match "stop", so normalize first (e.g. command.toLowerCase()) if the input casing varies. One more gotcha: if command is null, the switch throws a NullPointerException, so guard against null before you reach it.

The Modern Arrow Syntax

Newer Java (14+) adds an arrow form, case label -> ..., that fixes the fall-through trap by design. Each arrow case runs exactly one branch and never falls through, so there is no break to forget:

public class Main {
    public static void main(String[] args) {
        int day = 6;

        switch (day) {
            case 1, 2, 3, 4, 5 -> System.out.println("Weekday");
            case 6, 7          -> System.out.println("Weekend");
            default            -> System.out.println("Invalid day");
        }
    }
}

Notice you group values with a comma (case 6, 7) instead of stacking labels, and there is not a single break in sight. For multiple statements, use a block: case 1 -> { ...; ... }. Prefer this form in new code - it is shorter and removes a whole class of bugs.

switch as an Expression

The arrow form can also produce a value. A switch expression returns a result you can assign straight to a variable - no temporary, no repeated assignment in every branch:

public class Main {
    public static void main(String[] args) {
        int month = 4;

        int days = switch (month) {
            case 1, 3, 5, 7, 8, 10, 12 -> 31;
            case 4, 6, 9, 11           -> 30;
            case 2                     -> 28;
            default -> throw new IllegalArgumentException("Bad month: " + month);
        };

        System.out.println("Days: " + days);
    }
}

The whole switch (...) { ... } evaluates to a number stored in days. Note the semicolon after the closing brace - it is part of the assignment statement. A switch expression must be exhaustive (cover every possible value), which is why default is here - and notice that an unmatched branch can throw an exception instead of returning a value. If a branch needs multiple statements before returning a value, use a block with yield:

case 2 -> {
    boolean leap = (year % 4 == 0);
    yield leap ? 29 : 28;
}

yield is how an arrow block hands back its value, the expression-world equivalent of break carrying a result.

Next: for Loops

switch picks one branch out of many; sometimes you instead need to repeat a block many times. The for loop runs code a controlled number of times - counting through a range or stepping over each item - and it is the next page.