{"title":"Switch Statement","description":"","content":"When you find yourself writing an `if`-`else if` chain that compares the same variable against many constant values, a `switch` statement is usually cleaner. Java reads the value once and jumps straight to the matching branch. This lesson covers the classic `switch` statement form, the types it accepts, and the fall-through behavior that surprises almost everyone the first time they hit it.\n\n---\n\n# When to Use `switch`\n\nA `switch` statement compares one expression against a list of constant `case` labels. If a label matches, control jumps to that label and runs the code beneath it. If nothing matches, control falls into the `default` block (if you wrote one).\n\nConsider an order tracker that needs to print a different message for each order status. With `if`-`else if`, you end up repeating the variable name in every condition:\n\n\n```java\npublic class OrderStatusIfElse {\n public static void main(String[] args) {\n String orderStatus = \"SHIPPED\";\n\n if (orderStatus.equals(\"PLACED\")) {\n System.out.println(\"We received your order.\");\n } else if (orderStatus.equals(\"SHIPPED\")) {\n System.out.println(\"Your order is on its way.\");\n } else if (orderStatus.equals(\"DELIVERED\")) {\n System.out.println(\"Your order has arrived.\");\n } else if (orderStatus.equals(\"CANCELLED\")) {\n System.out.println(\"Your order was cancelled.\");\n } else {\n System.out.println(\"Unknown status.\");\n }\n }\n}\n```\n\n\nThe same logic with `switch` reads as a table of cases instead of a chain of comparisons:\n\n\n```java\npublic class OrderStatusSwitch {\n public static void main(String[] args) {\n String orderStatus = \"SHIPPED\";\n\n switch (orderStatus) {\n case \"PLACED\":\n System.out.println(\"We received your order.\");\n break;\n case \"SHIPPED\":\n System.out.println(\"Your order is on its way.\");\n break;\n case \"DELIVERED\":\n System.out.println(\"Your order has arrived.\");\n break;\n case \"CANCELLED\":\n System.out.println(\"Your order was cancelled.\");\n break;\n default:\n System.out.println(\"Unknown status.\");\n }\n }\n}\n```\n\n\nSame result, but the structure tells the reader what you're doing: dispatching on one value. A good rule of thumb: use `switch` when comparing one variable against a fixed set of constant values, and use `if`-`else if` when conditions involve ranges, multiple variables, or non-constant expressions.\n\nHow that dispatch flows:\n\n\n```mermaid\nflowchart TD\n A[Read orderStatus]:::cyan --> B{Match a case?}:::orange\n B -- \"PLACED\" --> C[Print received]:::teal\n B -- \"SHIPPED\" --> D[Print on its way]:::green\n B -- \"DELIVERED\" --> E[Print arrived]:::green\n B -- \"CANCELLED\" --> F[Print cancelled]:::red\n B -- \"no match\" --> G[default: Print unknown]:::orange\n C --> H[Exit switch]:::cyan\n D --> H\n E --> H\n F --> H\n G --> H\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef red fill:#ff8787,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n```\n\n\nThe diamond at the top is the dispatch step. The switch reads `orderStatus` once, picks the matching branch, runs the code under it, then exits. If no `case` matches, control lands in `default`.\n\n---\n\n# What Types Can You Switch On?\n\n`switch` doesn't accept arbitrary expressions. The value in the parentheses must be one of these:\n\n\n| Type | Notes |\n| --------- | ---------------------------------------------------- |\n| `byte` | Including its wrapper `Byte` |\n| `short` | Including its wrapper `Short` |\n| `int` | Including its wrapper `Integer` |\n| `char` | Including its wrapper `Character` |\n| `String` | Supported since Java 7 |\n| `enum` | Any enum type |\n\n\nWhat's missing from this list matters: you can't switch on `long`, `float`, `double`, `boolean`, or arbitrary objects. Each `case` label must be a compile-time constant of the same type as the switch expression.\n\nA small example using `int` for a customer tier code:\n\n\n```java\npublic class CustomerTierByCode {\n public static void main(String[] args) {\n int tierCode = 2;\n\n switch (tierCode) {\n case 1:\n System.out.println(\"Bronze tier: 5% discount\");\n break;\n case 2:\n System.out.println(\"Silver tier: 10% discount\");\n break;\n case 3:\n System.out.println(\"Gold tier: 20% discount\");\n break;\n default:\n System.out.println(\"No tier assigned.\");\n }\n }\n}\n```\n\n\nAnd one with `char` for a product category code:\n\n\n```java\npublic class CategoryByChar {\n public static void main(String[] args) {\n char categoryCode = 'E';\n\n switch (categoryCode) {\n case 'B':\n System.out.println(\"Books\");\n break;\n case 'E':\n System.out.println(\"Electronics\");\n break;\n case 'C':\n System.out.println(\"Clothing\");\n break;\n default:\n System.out.println(\"Other\");\n }\n }\n}\n```\n\n\n---\n\n# Switching on `String`\n\nSwitching on `String` was added in Java 7, and it's one of the most common uses today. The comparison uses `.equals()` internally, so case matters: `\"shipped\"` doesn't match `\"SHIPPED\"`.\n\n\n```java\npublic class ShippingMethodPrice {\n public static void main(String[] args) {\n String shippingMethod = \"EXPRESS\";\n\n switch (shippingMethod) {\n case \"STANDARD\":\n System.out.println(\"Shipping cost: $5.00\");\n break;\n case \"EXPRESS\":\n System.out.println(\"Shipping cost: $12.00\");\n break;\n case \"OVERNIGHT\":\n System.out.println(\"Shipping cost: $25.00\");\n break;\n default:\n System.out.println(\"Unknown shipping method.\");\n }\n }\n}\n```\n\n\nOne thing to watch: if the string is `null`, `switch` throws `NullPointerException` before any case is checked. Guard with a null check if the value can be missing.\n\n\n```java\npublic class NullShippingMethod {\n public static void main(String[] args) {\n String shippingMethod = null;\n\n if (shippingMethod == null) {\n System.out.println(\"Please pick a shipping method.\");\n } else {\n switch (shippingMethod) {\n case \"STANDARD\":\n System.out.println(\"Standard shipping selected.\");\n break;\n default:\n System.out.println(\"Other method selected.\");\n }\n }\n }\n}\n```\n\n\nSwitching on `String` isn't free. The compiler turns it into a `hashCode()` lookup followed by an `equals()` check. It's still fast, but if a `String` switch sits in a hot loop and the set of cases is tiny, an `if`-`else if` with `==` on an `enum` or `int` constant is faster.\n\n---\n\n# Switching on an `enum`\n\nEnums and `switch` are made for each other. The case labels are the enum constants themselves, with no class prefix, and the compiler can warn you if you forget one.\n\n\n```java\npublic class CustomerTierByEnum {\n enum Tier { BRONZE, SILVER, GOLD, PLATINUM }\n\n public static void main(String[] args) {\n Tier tier = Tier.GOLD;\n\n switch (tier) {\n case BRONZE:\n System.out.println(\"5% discount\");\n break;\n case SILVER:\n System.out.println(\"10% discount\");\n break;\n case GOLD:\n System.out.println(\"20% discount\");\n break;\n case PLATINUM:\n System.out.println(\"30% discount\");\n break;\n }\n }\n}\n```\n\n\nThere's no `default` here. With enums, you can sometimes leave it out if every constant is covered, but adding a `default` is still a safer habit. If someone adds a new constant later (`DIAMOND`, for example), the old switch does nothing for it. A `default` that prints or logs makes that case visible instead of swallowing it.\n\n---\n\n# `case`, `default`, and `break`\n\nA `case` label marks an entry point into the switch. The `default` label is the entry point used when nothing else matches. `break` is the exit door: it ends the switch and jumps to the statement after the closing brace.\n\nTwo rules:\n\n- `default` doesn't have to be last, but putting it last is the convention because that's where readers expect it.\n- You can have at most one `default` per switch.\n\nThe basic shape with all three:\n\n\n```java\npublic class OrderActionByStatus {\n public static void main(String[] args) {\n String orderStatus = \"DELIVERED\";\n\n switch (orderStatus) {\n case \"PLACED\":\n System.out.println(\"Send confirmation email.\");\n break;\n case \"SHIPPED\":\n System.out.println(\"Send tracking link.\");\n break;\n case \"DELIVERED\":\n System.out.println(\"Request a review.\");\n break;\n default:\n System.out.println(\"No action.\");\n }\n\n System.out.println(\"Done.\");\n }\n}\n```\n\n\n`break` makes the difference between \"run this case and stop\" and \"run this case and keep going\". Drop the `break` and you get fall-through, which is the next thing we need to talk about.\n\n---\n\n# Fall-Through: The Bug Magnet\n\nWithout a `break`, control flows from one matched case into the case below it, and the one below that, until it hits a `break` or the end of the switch. This is **fall-through**. Java inherited it from C and it's the source of the most common `switch` bug.\n\n**What's wrong with this code?**\n\n\n```java\npublic class BrokenTierDiscount {\n public static void main(String[] args) {\n String customerTier = \"SILVER\";\n int discount = 0;\n\n switch (customerTier) {\n case \"BRONZE\":\n discount = 5;\n case \"SILVER\":\n discount = 10;\n case \"GOLD\":\n discount = 20;\n default:\n System.out.println(\"Discount: \" + discount + \"%\");\n }\n }\n}\n```\n\n\nThe author meant the discount for `SILVER` to be 10%, but they got 20%. The reason: control jumps to `case \"SILVER\":` and sets `discount = 10`. There's no `break`, so it falls through to `case \"GOLD\":` and overwrites `discount` with `20`. Then it falls into `default` and prints `20%`.\n\n**Fix:**\n\n\n```java\npublic class FixedTierDiscount {\n public static void main(String[] args) {\n String customerTier = \"SILVER\";\n int discount = 0;\n\n switch (customerTier) {\n case \"BRONZE\":\n discount = 5;\n break;\n case \"SILVER\":\n discount = 10;\n break;\n case \"GOLD\":\n discount = 20;\n break;\n default:\n discount = 0;\n }\n\n System.out.println(\"Discount: \" + discount + \"%\");\n }\n}\n```\n\n\nEach case now has its own `break`. The `default` doesn't need one because nothing comes after it inside the switch.\n\nWhen you read someone else's switch, scan the right margin first. Every case body should end in a `break` (or `return`, or `throw`). If one doesn't, either it's a deliberate fall-through, in which case a comment should say so, or it's a bug waiting to happen.\n\n---\n\n# Intentional Fall-Through: Grouping Cases\n\nFall-through isn't only a bug. When two or more cases share the same body, you can group them by stacking the labels with no code between them. Control enters at the first matching label and runs straight down to the shared body.\n\n\n```java\npublic class ShippingCostByMethod {\n public static void main(String[] args) {\n String shippingMethod = \"TWO_DAY\";\n double cost;\n\n switch (shippingMethod) {\n case \"STANDARD\":\n case \"ECONOMY\":\n cost = 5.00;\n break;\n case \"EXPRESS\":\n case \"TWO_DAY\":\n cost = 12.00;\n break;\n case \"OVERNIGHT\":\n cost = 25.00;\n break;\n default:\n cost = 0;\n }\n\n System.out.println(\"Shipping cost: $\" + cost);\n }\n}\n```\n\n\n`STANDARD` and `ECONOMY` share the `$5.00` body. `EXPRESS` and `TWO_DAY` share the `$12.00` body. This is the clean, idiomatic form. Two stacked labels right next to each other read as \"either of these\", and nobody mistakes them for a bug.\n\nYou can also fall through with real code in between, but that's where readers start losing the thread. If you absolutely need to do that, add a comment so the next person knows it's deliberate:\n\n\n```java\ncase \"STANDARD\":\n addBaseShipping();\n // fall through\ncase \"ECONOMY\":\n addInsurance();\n break;\n```\n\n\nMost teams avoid this pattern entirely. Stacked labels for shared bodies are fine. Code-with-fall-through is rarely worth the confusion.\n\n---\n\n# Variable Scope Inside a Switch\n\nOne subtle point: variables declared inside a `switch` block share a single scope that spans every case. You can't declare the same variable name in two different cases without using extra braces, because the second declaration would clash with the first.\n\n**What's wrong with this code?**\n\n\n```java\npublic class ScopeClash {\n public static void main(String[] args) {\n int tierCode = 2;\n\n switch (tierCode) {\n case 1:\n String label = \"Bronze\";\n System.out.println(label);\n break;\n case 2:\n String label = \"Silver\";\n System.out.println(label);\n break;\n }\n }\n}\n```\n\n\nThis won't compile. The error is something like `variable label is already defined in the scope`. Both `String label` declarations live in the same switch block, even though they're in different cases.\n\n**Fix:** wrap each case body in its own block with `{}` to create a new scope:\n\n\n```java\npublic class ScopeFixed {\n public static void main(String[] args) {\n int tierCode = 2;\n\n switch (tierCode) {\n case 1: {\n String label = \"Bronze\";\n System.out.println(label);\n break;\n }\n case 2: {\n String label = \"Silver\";\n System.out.println(label);\n break;\n }\n }\n }\n}\n```\n\n\nThe braces give each case its own scope, so `label` no longer clashes. You only need this trick when you declare variables inside cases. If your cases just call methods or assign to variables declared outside the switch, the braces are noise.\n\n---\n\n# A Note on the Newer Arrow Form\n\nJava has a newer `switch` syntax with arrows (`case X -> ...`) that doesn't fall through and can return a value. Everything in this lesson is the classic statement form, which still works in every Java version and shows up in most existing codebases. Learn this form first, then the arrow form will feel like a cleaner version of the same idea.","pageType":"java"}

Switch Statement

Get Premium