All 15 Enums questions
More in Enums
What are the ordinal() and name() methods on an enum constant, and why is relying on ordinal() for persistence or serialization considered dangerous? 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? 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 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? How would you implement a custom compareTo()-based ordering for an enum that differs from its natural declaration-order ordering, given Comparable's default implementation uses ordinal()? How would you handle adding behavior to an enum where the number of constants might grow very large or needs to be data-driven rather than hardcoded at compile time, and why might a class-based registry be more appropriate in that scenario?
Advertisement
Java › Enums

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?

Advanced

Answer

An enum can have each individual constant override an abstract method with its own unique implementation (a "constant-specific class body"), letting the enum itself directly encapsulate a fixed, closed set of interchangeable algorithms/strategies without needing separate implementation classes -- this is a particularly clean fit specifically when the set of strategies is genuinely fixed and known in advance (unlike a general Strategy pattern via an interface, which supports an open-ended, extensible set of implementations), trading that extensibility for enum's built-in singleton-per-constant simplicity and exhaustiveness-checkable switch support.
public enum Operation {
    ADD { public double apply(double a, double b) { return a + b; } },
    SUBTRACT { public double apply(double a, double b) { return a - b; } },
    MULTIPLY { public double apply(double a, double b) { return a * b; } };

    public abstract double apply(double a, double b);  // each constant provides its own implementation
}

double result = Operation.ADD.apply(3, 4);  // 7.0, dispatches directly to ADD's own implementation
Real-world example A simple calculator's arithmetic operations are modeled as an Operation enum with constant-specific apply() implementations, avoiding both a large if/else or switch chain AND the need for four separate small implementation classes that a traditional interface-based Strategy pattern would require for this same fixed, closed set of operations.

Common follow-ups: When would a traditional interface-based Strategy implementation still be preferable to this enum-based approach?;What's the memory/performance characteristic of constant-specific method bodies compared to a switch-based dispatch?

Design Patterns in Java;Functional Interfaces & Method References
All 15 Enums questions