switch works when you're checking one variable against a list of exact values. It doesn't work for range checks (x > 10), complex conditions (a && b), or String comparisons with .equals(). For those, if/else is still the right tool.

The Problem `switch` Solves

Consider a program that prints the day name for a number:

Java

// With else-if — repetitive and verbose:
if (day == 1) {
    System.out.println("Monday");
} else if (day == 2) {
    System.out.println("Tuesday");
} else if (day == 3) {
    System.out.println("Wednesday");
} else if (day == 4) {
    System.out.println("Thursday");
} else if (day == 5) {
    System.out.println("Friday");
} else if (day == 6) {
    System.out.println("Saturday");
} else if (day == 7) {
    System.out.println("Sunday");
} else {
    System.out.println("Invalid day");
}

With switch:

Java

// With switch — clean and scannable:
switch (day) {
    case 1: System.out.println("Monday");    break;
    case 2: System.out.println("Tuesday");   break;
    case 3: System.out.println("Wednesday"); break;
    case 4: System.out.println("Thursday");  break;
    case 5: System.out.println("Friday");    break;
    case 6: System.out.println("Saturday");  break;
    case 7: System.out.println("Sunday");    break;
    default: System.out.println("Invalid day");
}

Same logic. Half the lines. Instantly scannable — you can see every possible value at a glance.

The Traditional `switch` Statement

Syntax:

Java

switch (expression) {
    case value1:
        // code for value1
        break;
    case value2:
        // code for value2
        break;
    // ... more cases
    default:
        // code if no case matches
}

Breaking down each part:

›switch (expression) — the value being tested. Must be int, char, String, byte, short, or an enum. Cannot be double, float, long, or boolean.
›case value: — a specific value to match against. Must be a constant — not a variable.
›break — exits the switch block. Without it, execution falls into the next case (see fall-through below).
›default — runs when no case matches. Optional, but recommended. Like else in an if chain.

Complete example:

Java

import java.util.Scanner;

public class DayPrinter {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter day number (1-7): ");
        int day = scanner.nextInt();

        switch (day) {
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday");
                break;
            case 4:
                System.out.println("Thursday");
                break;
            case 5:
                System.out.println("Friday");
                break;
            case 6:
                System.out.println("Saturday");
                break;
            case 7:
                System.out.println("Sunday");
                break;
            default:
                System.out.println("Invalid day number.");
        }

        scanner.close();
    }
}

Sample output:

Enter day number (1-7): 3
Wednesday

How `switch` Works — Step by Step

›Java evaluates the switch expression (day = 3)
›It compares against each case from top to bottom
›When it finds a match (case 3), it runs that block
›break exits the entire switch — remaining cases are skipped
›If no case matches, default runs

Fall-Through — What Happens Without `break`

Forgetting break is the most common switch mistake — but fall-through is also sometimes used intentionally.

Without break — fall-through happens:

Java

int day = 3;

switch (day) {
    case 1:
        System.out.println("Monday");
    case 2:
        System.out.println("Tuesday");
    case 3:
        System.out.println("Wednesday");   // ← matches here
    case 4:
        System.out.println("Thursday");    // ← falls through!
    case 5:
        System.out.println("Friday");      // ← falls through!
    default:
        System.out.println("Weekend");     // ← falls through!
}

Output:

Wednesday
Thursday
Friday
Weekend

Once a case matches, Java executes all subsequent cases regardless of their values — until it hits a break or the end of the switch.

Intentional fall-through — grouping cases:

Fall-through is useful when multiple values should run the same code:

Java

int month = 4;   // April

switch (month) {
    case 1:
    case 3:
    case 5:
    case 7:
    case 8:
    case 10:
    case 12:
        System.out.println("31 days");
        break;
    case 4:
    case 6:
    case 9:
    case 11:
        System.out.println("30 days");   // ← April hits this
        break;
    case 2:
        System.out.println("28 or 29 days");
        break;
    default:
        System.out.println("Invalid month");
}

Output:

30 days

Empty cases stack up — case 4:, case 6:, case 9:, case 11: all fall through to the same println. This is deliberate and clean — no code is repeated.

⚠️ Accidental fall-through is a common bug. Always add break at the end of every case unless you intentionally want fall-through. When fall-through is intentional, add a comment:

Java

case 4:
case 6:   // fall-through intentional — same days count
case 9:

`switch` with Strings

From Java 7 onwards, switch works with String values:

Java

String season = "Winter";

switch (season) {
    case "Spring":
        System.out.println("Flowers bloom.");
        break;
    case "Summer":
        System.out.println("Hot and sunny.");
        break;
    case "Autumn":
        System.out.println("Leaves fall.");
        break;
    case "Winter":
        System.out.println("Cold and dry.");   // ← matches
        break;
    default:
        System.out.println("Unknown season.");
}

Output:

Cold and dry.

⚠️ String switch is case-sensitive. "winter" does NOT match case "Winter". Always ensure the case in your switch matches the exact case of the input string.

Java

switch (season.toLowerCase()) {   // normalize to lowercase first
    case "spring": ...
    case "summer": ...
}

The Modern Switch Expression (Java 14+)

Java 14 introduced a cleaner switch syntax that eliminates break, prevents fall-through by design, and can return a value directly.

Traditional switch (old way):

Java

String day = "MONDAY";
String type;

switch (day) {
    case "MONDAY":
    case "TUESDAY":
    case "WEDNESDAY":
    case "THURSDAY":
    case "FRIDAY":
        type = "Weekday";
        break;
    case "SATURDAY":
    case "SUNDAY":
        type = "Weekend";
        break;
    default:
        type = "Unknown";
}

System.out.println(type);

Switch expression (modern way):

Java

String day = "MONDAY";

String type = switch (day) {
    case "MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY" -> "Weekday";
    case "SATURDAY", "SUNDAY" -> "Weekend";
    default -> "Unknown";
};

System.out.println(type);   // Weekday

What changed:

Feature	Traditional switch	Switch Expression (Java 14+)
`break` required	✅ Yes	❌ No
Fall-through possible	✅ Yes (bug risk)	❌ No (by design)
Multiple values per case	❌ Stack empty cases	✅ `case A, B, C ->`
Returns a value	❌ No	✅ Yes (assign directly)
Arrow syntax	❌	✅ `->`

More switch expression examples:

Java

// Grade based on marks
int marks = 82;

String grade = switch (marks / 10) {
    case 10, 9 -> "A";
    case 8     -> "B";
    case 7     -> "C";
    case 6     -> "D";
    default    -> "F";
};

System.out.println("Grade: " + grade);   // Grade: B

Java

// Number of days in a month
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("Invalid month: " + month);
};

System.out.println(month + " has " + days + " days.");   // 4 has 30 days.

💡 Use the modern switch expression when you can. It is less error-prone (no accidental fall-through), more concise, and directly returns values. If you are on Java 14 or later — and most projects are — prefer -> over the traditional colon syntax.

`switch` vs `if/else` — When to Use Which

Java

// Use switch — one variable, exact values:
switch (command) {
    case "start" -> startEngine();
    case "stop"  -> stopEngine();
    case "pause" -> pauseEngine();
    default      -> System.out.println("Unknown command");
}

// Use if/else — range check, not exact value:
if (temperature < 0) {
    System.out.println("Freezing");
} else if (temperature < 20) {
    System.out.println("Cold");
} else {
    System.out.println("Warm");
}

A Complete Example — Menu-Driven Calculator

Java

import java.util.Scanner;

public class Calculator {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);

        System.out.print("Enter first number:  ");
        double a = scanner.nextDouble();

        System.out.print("Enter second number: ");
        double b = scanner.nextDouble();

        System.out.print("Enter operator (+, -, *, /): ");
        String op = scanner.next();

        double result = switch (op) {
            case "+" -> a + b;
            case "-" -> a - b;
            case "*" -> a * b;
            case "/" -> {
                if (b == 0) {
                    System.out.println("Error: division by zero.");
                    yield 0;   // 'yield' returns a value from a block in switch expression
                }
                yield a / b;
            }
            default -> {
                System.out.println("Unknown operator: " + op);
                yield 0;
            }
        };

        System.out.println(a + " " + op + " " + b + " = " + result);
        scanner.close();
    }
}

Sample output:

Enter first number:  15
Enter second number: 4
Enter operator (+, -, *, /): /
15.0 / 4.0 = 3.75

💡 yield is used inside a block ({ }) in a switch expression to return a value. When the case uses -> with a single expression, yield is not needed. When the case needs multiple statements, wrap them in { } and use yield to return the result.

Common Mistakes

1. Forgetting break — accidental fall-through

Java

switch (day) {
    case 1:
        System.out.println("Monday");   // runs
        // ← missing break!
    case 2:
        System.out.println("Tuesday");  // also runs — unintended!
}

Fix: add break at the end of every case, or use the modern -> syntax.

2. Using a variable as a case value

Java

int limit = 100;

switch (x) {
    case limit:   // ❌ error — case values must be constants
        ...
}

switch (x) {
    case 100:   // ✅ literal constant
        ...
}

3. Using unsupported types

Java

double price = 9.99;
switch (price) { ... }   // ❌ error — double not supported

boolean flag = true;
switch (flag) { ... }    // ❌ error — boolean not supported

long big = 100L;
switch (big) { ... }     // ❌ error — long not supported

Supported types: int, byte, short, char, String, enums (and their wrapper types Integer, Character, etc.)

4. Case-sensitive String matching

Java

String input = "winter";

switch (input) {
    case "Winter":   // ❌ no match — "winter" ≠ "Winter"
        System.out.println("Cold");
}

switch (input.toLowerCase()) {
    case "winter":   // ✅ normalize first
        System.out.println("Cold");
}

5. Missing default

Java

switch (status) {
    case "active":  System.out.println("Running"); break;
    case "paused":  System.out.println("Paused");  break;
    // What if status is "error" or "unknown"? Silent — nothing happens
}

Always include default to handle unexpected values explicitly.

Quick Reference

Java

// Traditional switch
switch (variable) {
    case value1:
        // code
        break;
    case value2:
    case value3:     // fall-through — both run this block
        // code
        break;
    default:
        // code if no match
}

// Switch expression (Java 14+) — preferred
String result = switch (variable) {
    case value1        -> "result1";
    case value2, value3 -> "result2";    // multiple values — clean syntax
    default            -> "default result";
};

// Switch expression with block and yield
int output = switch (x) {
    case 1 -> 10;
    case 2 -> {
        int temp = x * 5;
        yield temp + 1;   // return value from block
    }
    default -> 0;
};

The 3 Things to Remember From This Page

›Always add break in traditional switch — or use the modern -> syntax which prevents fall-through by design. Forgetting break is the most common switch bug.
›switch only works with exact values, not ranges — use switch for day == 3, use if/else for score >= 60. Trying to use switch for range checks won't work.
›Prefer the modern switch expression (->) when on Java 14+. It's shorter, has no fall-through risk, supports multiple values per case with commas, and can return a value directly.

Summary

›switch matches one expression against a list of exact case values
›break exits the switch — without it, execution falls through to the next case
›default runs when no case matches — always include it
›Fall-through is usually a bug (missing break), but can be intentional for grouping cases
›switch supports: int, byte, short, char, String, enums (not double, float, long, boolean)
›String switch is case-sensitive — normalize with .toLowerCase() if needed
›Modern switch expression (->, Java 14+): no break, no fall-through, multiple values per case, returns a value
›yield returns a value from a block { } inside a switch expression
›Use switch for exact value matching on one variable. Use if/else for ranges, multiple variables, and complex conditions.

What to Read Next

Topic	Link
if / else — conditional statements	if / else / else-if →
for loop — repeating code a fixed number of times	for Loop →
Enums — the perfect companion for switch	Enums →
Switch expressions in depth (Java 14–21)	Switch Expressions →
Operators — comparison operators used in switch	Operators →