.JAVA File Format – Enum classes

Declaration

EnumDeclaration:
    {ClassModifier} enum TypeIdentifier [ClassImplements] EnumBody

EnumBody:
    { [EnumConstantList] [,] [EnumBodyDeclarations] }

EnumConstant:
    {EnumConstantModifier} Identifier [( [ArgumentList] )] [ClassBody]

EnumBodyDeclarations:
    ; {ClassBodyDeclaration}

enum Day { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY }

public enum Planet {
    MERCURY(3.303e+23, 2.4397e6),
    EARTH  (5.976e+24, 6.37814e6),
    JUPITER(1.9e+27,   7.1492e7);           // the semicolon ends the constant list

    private static final double G = 6.67300E-11;
    private final double mass, radius;

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

    double surfaceGravity() { return G * mass / (radius * radius); }
}

• The constants come first, separated by commas; a trailing comma is allowed. If anything follows them, they end with a semicolon.
• Each constant is a public static final field of the enum type, and may carry annotations and arguments for a constructor.
• An enum’s direct superclass is Enum<E>. It cannot have an extends clause, but may implement interfaces.
• An enum cannot be declared abstract, final, sealed or non-sealed. It is implicitly final, unless a constant has a class body, when it is implicitly sealed, with those bodies as its only subclasses.
• Nested and local enums are implicitly static.
• An enum may be empty: enum None {}, or enum Util { ; static void f() {} }.

Constructors and initialisation

• Constructors are implicitly private; public or protected is an error. They cannot call super(…).
• new on an enum type is an error, and so is cloning or creating an instance by reflection; serialisation reads constants back by name, so they stay unique.
• The constants are created in order, when the enum class is initialised, before its other static fields. So a constructor or instance initialiser may not refer to a static field of the enum unless it is a constant variable: the field would not be set yet.

Constant-specific class bodies

A constant may have a class body, which declares an anonymous subclass of the enum for that constant alone. This gives each constant its own method implementations:

enum Operation {
    PLUS("+")  { int apply(int a, int b) { return a + b; } },
    MINUS("-") { int apply(int a, int b) { return a - b; } },
    TIMES("*") { int apply(int a, int b) { return a * b; } };

    final String symbol;
    Operation(String symbol) { this.symbol = symbol; }

    abstract int apply(int a, int b);     // allowed: every constant implements it
}

An enum may declare an abstract method only if it has at least one constant and every constant has a body that implements it. A constant body cannot declare constructors.

Implicit members

An enum may not declare its own values(), valueOf(String), or a finalize method. java.util has EnumSet and EnumMap, compact collections keyed by ordinal.

Enums in switch

A switch on an enum value uses the bare constant names as labels. Since Java 21 the qualified name, such as Day.MONDAY, is allowed too, which matters when the selector is of a sealed interface type that enums implement. A switch expression over an enum is exhaustive when it lists every constant, with no default. The compiler then adds a hidden default that throws an error, in case a constant is added to the enum later and the switch is not recompiled.

static boolean weekend(Day d) {
    return switch (d) {
        case SATURDAY, SUNDAY -> true;
        case MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY -> false;
    };
}

See Switch for the full rules.