All 15 Enums questions
More in Enums
How do you add fields, constructors, and methods to a Java enum, and how would you implement an enum representing planets with mass and radius that calculates surface gravity? How does the EnumSet and EnumMap provide more efficient alternatives to HashSet<Enum> and HashMap<Enum, V> specifically for enum keys? How would you implement an enum that also implements an interface, and what's the benefit of having different enum constants provide different behavior through a shared interface contract? What are the ordinal() and name() methods on an enum constant, and why is relying on ordinal() for persistence or serialization considered dangerous? What is the valueOf() method on an enum, and what happens when you pass a name that doesn't match any declared constant? How would you use an enum to represent a fixed set of configuration keys combined with a shared lookup method, avoiding scattered String literal keys throughout a codebase? How would you implement the Strategy pattern using an enum with constant-specific method bodies, and how does this compare to a traditional interface-based Strategy implementation? How does Java implement enums under the hood at the bytecode level (extending java.lang.Enum), and what makes them inherently thread-safe and serialization-safe as singletons? How would you use an EnumMap combined with a switch expression to implement a state machine, and what compile-time safety benefits does an exhaustive switch over an enum provide? How would you implement a custom enum that also functions as a lookup table (mapping an external code to a constant), such as parsing an HTTP status code string into an enum constant, handling unknown values gracefully?
Advertisement
Java › Enums

How do you correctly use an enum as a switch statement/expression's target, and what changed with the introduction of arrow-style switch expressions (Java 14+) regarding exhaustiveness and fall-through?

Intermediate

Answer

Traditional colon-style switch statements over an enum use unqualified constant names in each case label (not Day.MONDAY, just MONDAY) and are prone to accidental fall-through if a break is forgotten; the newer arrow-style switch expressions (case X -> ...) eliminate fall-through entirely (each branch is independent, no accidental cascade into the next case), can directly return a value as an expression, and when covering every enum constant without a default branch, give the compiler the ability to verify exhaustiveness at compile time, immediately flagging if a new constant is later added without a corresponding case being handled.
enum Size { SMALL, MEDIUM, LARGE }

// Old style: fall-through risk if break is forgotten
switch (size) {
    case SMALL: System.out.println("S"); break;
    case MEDIUM: System.out.println("M"); break;
    case LARGE: System.out.println("L"); break;
}

// Modern arrow style: no fall-through risk, can be an expression, exhaustiveness-checkable
String label = switch (size) {
    case SMALL -> "S";
    case MEDIUM -> "M";
    case LARGE -> "L";
};
Real-world example A refactor from an old colon-style switch statement (which had a latent bug where a missing break caused unintended fall-through between two size cases) to the modern arrow-style switch expression both fixes the fall-through bug structurally (impossible in the new syntax) and gains compile-time exhaustiveness checking as a bonus safety improvement.

Common follow-ups: What happens if you DO include a default case in an arrow-style switch over an enum -- does the compiler still warn about missing constants?;Why was colon-style switch's fall-through behavior originally designed that way, and is it ever still useful?

Pattern Matching & Switch Expressions;Java Fundamentals: Syntax Data Types & Operators
All 15 Enums questions