What is the traditional switch statement in Java, and how does control flow move through its cases?

## What problem switch solves When you need to do different things depending on the value of a single variable, you could write a long `if / else if / else` chain. The **switch statement** is a more compact, readable alternative for that specific shape: *one* value compared for equality against *many* constant possibilities. ## Anatomy ```java switch (selector) { // selector = the expression being tested case A: // case label A — a constant // statements break; // stop here case B: // statements break; default: // optional catch-all // statements } ``` - **Selector expression**: the value in the parentheses. It is evaluated once. - **case label**: `case <constant>:` — a possible value to match. The thing after `case` must be a **compile-time constant** (a literal, a `final` constant, or an enum constant), not a variable or arbitrary expression. Labels must be **unique** — two `case 1:` in the same switch is a compile error. - **default label**: runs when no case matched. It is optional. - **break**: a jump that exits the whole switch. ## Fall-through — the defining behavior A traditional switch does **not** stop after a matching case. It *jumps to* the matching label and then keeps executing **straight downward**, ignoring later `case`/`default` labels, until something transfers control out — a `break`, a `return`, a `throw`, or simply reaching the closing `}`. This is called **fall-through**. ```java int day = 3; switch (day) { case 1: System.out.println("one"); case 2: System.out.println("two"); case 3: System.out.println("three"); // matched here case 4: System.out.println("four"); // STILL runs — falls through! break; case 5: System.out.println("five"); // not reached, break stopped us } // prints: three, four ``` Fall-through is occasionally useful — you can let several labels share one body by stacking them with empty cases: ```java case 'a': case 'e': case 'i': case 'o': case 'u': return true; // any vowel ``` But accidental fall-through (a forgotten `break`) is one of the most common Java bugs, which is exactly why the modern `case L ->` arrow syntax was introduced (no fall-through). ## How matching works The selector value is compared to each case label for **equality**. For `String`, the comparison uses `.equals` (value equality) and is case-sensitive; the selector must not be `null` or you get a `NullPointerException`. Ranges and relational tests (`< 10`) are **not** allowed — each case is a single exact constant. ## default placement `default` is usually written last by convention, but the language does **not** require it to be last — it may appear anywhere among the cases, and it only runs when no case matched (or when control falls into it). If `default` is in the middle without a `break`, control can fall through from it into the following cases just like any other label. ## Statement, not expression The traditional switch is a **statement**: it performs actions but does not itself yield a value you can assign. To produce a value you assign inside the cases or use the newer **switch expression** (`int x = switch(...) { case A -> 1; ... };`). ## Summary mental model Think of case labels as *entry doors* into a single hallway of statements. switch picks the right door to enter, but once inside you keep walking down the hallway past the other doors until you hit an exit (`break`).