All 15 Enums questions
More in Enums
What is an enum in Java, and how does it differ from simply using a set of integer or String constants? How do you retrieve all constants of an enum type, and how would you iterate over them? 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? 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 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?
Advertisement
Back to results for “Design Patterns in Java”
Java › Enums

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?

Intermediate

Answer

An enum can implement one or more interfaces just like a regular class, either providing a single shared implementation for all constants, or combined with constant-specific method bodies to give each constant its own distinct implementation of the interface's methods -- this is useful when you want the type-safety and exhaustiveness benefits of an enum while still being able to pass enum constants around polymorphically wherever the interface type is expected, integrating enums cleanly into broader interface-based designs.
public interface Discount {
    double apply(double price);
}

public enum DiscountType implements Discount {
    NONE { public double apply(double price) { return price; } },
    PERCENT_10 { public double apply(double price) { return price * 0.9; } },
    FLAT_5 { public double apply(double price) { return Math.max(0, price - 5); } };
}

Discount discount = DiscountType.PERCENT_10;  // usable polymorphically anywhere a Discount is expected
System.out.println(discount.apply(100.0));
Real-world example A pricing engine defines DiscountType as an enum implementing a shared Discount interface, letting checkout code accept any Discount polymorphically (whether it's a fixed enum constant or, in theory, some other non-enum Discount implementation), while still getting the enum's built-in enumeration and switch-exhaustiveness benefits for the fixed set of standard discount types.

Common follow-ups: Can an enum implement multiple interfaces simultaneously, given it can't extend multiple classes?;How does this pattern compare to the constant-specific-method-body Strategy pattern example without an explicit interface?

Design Patterns in Java;Interfaces & Abstract Classes
All 15 Enums questions