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 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? 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 “OOP”
Java › 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?

Intermediate

Answer

Since each enum constant is a singleton instance, an enum can have instance fields (typically final, set via a private constructor invoked implicitly for each constant), and both regular instance methods (shared logic across all constants) and constant-specific method bodies (where an individual constant overrides a method uniquely for itself) -- letting an enum encapsulate not just a name but genuine associated data and behavior, going well beyond what a simple set of constants could express.
public enum Planet {
    MERCURY(3.303e+23, 2.4397e6),
    EARTH(5.976e+24, 6.37814e6);

    private final double mass;   // kg
    private final double radius; // meters

    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
    }

    public double surfaceGravity() {
        final double G = 6.67300E-11;
        return G * mass / (radius * radius);
    }
}

System.out.println(Planet.EARTH.surfaceGravity());
Real-world example A physics simulation models each solar system planet as an enum constant carrying its own mass and radius, with a shared surfaceGravity() calculation method available uniformly across every planet constant, encapsulating both the astronomical data and the derived calculation logic in one type-safe, self-documenting structure.

Common follow-ups: Why must an enum's constructor always be implicitly private, and what happens if you try to make it public?;How would you implement a method with a DIFFERENT implementation for each individual enum constant (constant-specific method bodies)?

OOP & Classes;Design Patterns in Java
All 15 Enums questions