Pattern Matching in switch

## Background: what a switch used to be A `switch` is a control-flow statement that picks one branch based on a value (the *selector*). Historically Java's switch could only compare the selector against **constant labels** using equality: integral types (`int`, `byte`, `short`, `char`), their boxed forms, `enum` constants, and (since Java 7) `String`. Each `case` was a constant; the runtime asked "does the selector equal this constant?" ```java switch (day) { // day is an int or enum case MONDAY: ...; break; case TUESDAY: ...; break; } ``` ## What a *pattern* is A **pattern** is a test-and-extract construct: it asks "does this value match a certain shape?" and, if so, **binds** (assigns) part of the value to a variable. The simplest pattern is the **type pattern**: a type name followed by a variable name, e.g. `Integer i`. Matching a value `v` against the type pattern `Integer i` means: *is `v` an instance of `Integer`? If yes, declare a variable `i` of type `Integer` and assign `v` to it.* This is exactly what `instanceof` pattern matching does: ```java if (obj instanceof Integer i) { // tests AND binds i use(i); // i is in scope here } ``` ## Type patterns inside switch Pattern matching in switch (finalized in Java 21) lets a `case` label be a **type pattern** instead of a constant: ```java static String describe(Object obj) { return switch (obj) { case Integer i -> "int " + i; // matches if obj is an Integer; binds i case String s -> "string " + s; // binds s case int[] a -> "array len " + a.length; default -> "other"; }; } ``` At runtime the switch evaluates the cases **in order**; the first whose type pattern the selector is an instance of wins. The matched value is cast to that type and bound to the case's variable, which is then usable in that branch only. ## Why this matters Without it, branching on runtime type meant a chain of `instanceof` + cast: ```java if (obj instanceof Integer) { Integer i = (Integer) obj; ... } else if (obj instanceof String) { String s = (String) obj; ... } ``` The pattern switch replaces this with a single, exhaustive, readable structure and removes the redundant casts. ## Key rules that come with it - **Exhaustiveness:** a switch that uses patterns (or has a result, like a switch *expression*) must cover all possible inputs. If you do not list every type, you must add a `default` (or, for sealed hierarchies, all permitted subtypes). The compiler enforces this. - **The selector type widens:** the selector may be any reference type (e.g. `Object`), not just the legacy switch types. - **Arrow form:** `case Label -> expr;` has no fall-through and scopes bindings to the branch. The old colon form (`case Label:`) still exists but is more error-prone with patterns. - **null:** a pattern switch does **not** silently accept `null`; by default `null` throws `NullPointerException` unless you add `case null` (covered separately). ## Deriving an answer From first principles: switch = pick a branch by value; a type pattern = "is it this type, and if so give me a typed variable"; combine them = a switch that branches on runtime type and hands you a ready-to-use, correctly-typed variable in each branch, replacing `instanceof`/cast ladders.