Java switch Statement

When you need to compare a single value against many possibilities, a long if/else if chain quickly becomes noisy. The switch statement is Java's compact alternative — read the value once, jump to the matching case, run its block.

Basic syntax

switch (value) {
  case label1:
    // body
    break;
  case label2:
    // body
    break;
  default:
    // body
    break;
}

A small example:

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("Other");
    break;
}

The switch jumps to case 3:, prints Wednesday, hits break, and exits.

The break is essential

Without break, execution falls through to the next case — even if its label doesn't match. This is a deliberate feature of the C-style switch, but it's the source of countless bugs in Java code:

switch (day) {
  case 1:
    System.out.println("Monday");
    // no break!
  case 2:
    System.out.println("Tuesday");
    break;
}

When day == 1, this prints both Monday and Tuesday. Always add break unless you intentionally want fall-through.

Intentional fall-through

Sometimes fall-through is exactly what you want — grouping multiple labels under the same block:

switch (day) {
  case 1:
  case 2:
  case 3:
  case 4:
  case 5:
    System.out.println("Weekday");
    break;
  case 6:
  case 7:
    System.out.println("Weekend");
    break;
}

When you do this on purpose, add a // fall through comment so reviewers don't think you forgot a break. (The new switch expression syntax — covered in the next chapter — fixes this footgun entirely.)

What can a switch value be?

A traditional switch accepts:

• All integer types: byte, short, int, char
• Their boxed wrappers: Byte, Short, Integer, Character
• String (since Java 7)
• enum constants

Not allowed: long, float, double, boolean, or arbitrary objects. For those, use if/else.

String role = "admin";

switch (role) {
  case "admin":
    System.out.println("Full access");
    break;
  case "editor":
    System.out.println("Write access");
    break;
  case "viewer":
    System.out.println("Read access");
    break;
  default:
    System.out.println("No access");
    break;
}

String comparison in a switch uses String.equals semantics — case-sensitive. One sharp edge: switching on a String (or any boxed/enum value) that is null throws a NullPointerException. Check for null before the switch, or handle it in a guard:

if (role == null) {
  System.out.println("No role");
} else {
  switch (role) {
    case "admin":
      System.out.println("Full access");
      break;
    // ...
  }
}

default — the catch-all

default runs when no case matches. It's not required, but including one is good practice; it makes the behavior for unexpected values explicit.

default doesn't have to be last. By convention it goes at the bottom, but the compiler accepts it anywhere — execution falls through it just like any other case if you forget break.

Rules to keep in mind

A couple of compiler-enforced rules trip people up:

• Case labels must be compile-time constants. You can use literals (case 3:), final constants, or enum names — but not a variable or a method call. case x: where x is a non-final variable won't compile.
• Labels must be unique. Two case 3: entries in the same switch are a compile error.
• All cases share one scope. A variable declared in one case is visible in the others, which can clash. Wrap a case body in { } braces when you need a local variable scoped to just that case:

switch (day) {
  case 1: {
    int hours = 8;
    System.out.println(hours);
    break;
  }
  case 2:
    // `hours` is not visible here
    break;
}

Switching on enum

enum and switch are a natural pair. Inside a switch on an enum value, you don't need to qualify the constant name:

enum Status { PENDING, ACTIVE, DONE }

Status s = Status.ACTIVE;

switch (s) {
  case PENDING:           // not Status.PENDING
    System.out.println("Waiting...");
    break;
  case ACTIVE:
    System.out.println("In progress");
    break;
  case DONE:
    System.out.println("Finished");
    break;
}

A worked example

What's next

Java 14 introduced switch expressions, which return a value, eliminate fall-through, and support multi-label cases — modern Java code prefers them whenever you're targeting Java 14 or newer.

Practice