Understanding Java Enums: Syntax Sugar, Compilation Details, and State‑Transition Implementation

Syntactic sugar, a term coined by Peter J. Landin, refers to language syntax that does not add new functionality but makes code easier to read and write; in Java, such sugar exists only at compile time, where the compiler removes it while generating the underlying bytecode.

Java provides many syntactic sugar features, including conditional compilation, assertions, switch on strings and enums, varargs, autoboxing/unboxing, enums, inner classes, generic type erasure, enhanced for‑loops, lambda expressions, and try‑with‑resources. The article focuses on enums.

Enum Classes

Since JDK 5, Java offers a special class type—enum—used when a set of constant values is known and fixed, providing a type‑safe alternative to traditional constant definitions.

Enums are declared with the enum keyword; multiple enum constants are separated by commas. A simple example is shown below:

public enum OrderStatus {
    //未支付、已支付、退款中、退款成功、退款失败；
    NO_PAY, PAY, REFUNDING, REFUNDED, FAIL_REFUNDED;
}

Enum constants can be accessed via ClassName.CONSTANT , and because the JVM guarantees a single instance per constant, they can be compared with == .

Important notes:

The first line of an enum must contain the enum constants; a trailing semicolon is optional unless additional members are defined. It is recommended not to omit the semicolon.

Enum constant names should be uppercase with underscores separating words (e.g., NO_PAY ).

Decompilation

Compiling OrderStatus.java produces OrderStatus.class . Using a decompiler such as DJ Java Decompiler reveals the generated bytecode, which includes a final class extending java.lang.Enum , private constructors, static final fields for each constant, and automatically generated methods like values() and valueOf(String) .

public final class OrderStatus extends Enum {
    public static final OrderStatus NO_PAY;
    public static final OrderStatus PAY;
    public static final OrderStatus REFUNDING;
    public static final OrderStatus REFUNDED;
    public static final OrderStatus FAIL_REFUNDED;
    private static final OrderStatus[] $VALUES;
    static {
        NO_PAY = new OrderStatus("NO_PAY", 0);
        PAY = new OrderStatus("PAY", 1);
        REFUNDING = new OrderStatus("REFUNDING", 2);
        REFUNDED = new OrderStatus("REFUNDED", 3);
        FAIL_REFUNDED = new OrderStatus("FAIL_REFUNDED", 4);
        $VALUES = new OrderStatus[]{NO_PAY, PAY, REFUNDING, REFUNDED, FAIL_REFUNDED};
    }
    // ... other generated methods ...
}

The compiler also creates anonymous inner‑class files for enum constant bodies that override methods.

State Transition Example

Requirement

In an e‑commerce system, an order progresses through states such as "unpaid", "paid", "refund in progress", etc. Transitions must follow business rules; for instance, an order cannot jump directly from "unpaid" to "refunded".

Implementation

The enum is extended with a custom canChange(OrderStatus) method that encodes allowed transitions for each state.

public enum OrderStatus {
    NO_PAY("未支付", 0) {
        @Override public Boolean canChange(OrderStatus target) {
            return target == PAY;
        }
    },
    PAY("已支付", 1) {
        @Override public Boolean canChange(OrderStatus target) {
            return target == REFUNDING;
        }
    },
    REFUNDING("退款中", 2) {
        @Override public Boolean canChange(OrderStatus target) {
            return target == REFUNDED || target == FAIL_REFUNDED;
        }
    },
    REFUNDED("退款成功", 3),
    FAIL_REFUNDED("退款失败", 4);

    private final String name;
    private final int status;
    private OrderStatus(String name, int status) { this.name = name; this.status = status; }
    public Boolean canChange(OrderStatus target) { return false; }
}

Usage example:

public class EnumTest {
    public static void main(String[] args) {
        Boolean a = OrderStatus.NO_PAY.canChange(OrderStatus.PAY);
        System.out.println("Can change: " + a);
        Boolean b = OrderStatus.REFUNDED.canChange(OrderStatus.FAIL_REFUNDED);
        System.out.println("Can change: " + b);
    }
}

The program prints whether each transition is permitted, illustrating how enums can enforce state‑transition rules.

Readers are encouraged to adapt the pattern to their own business logic and share ideas with the author.