> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # Java Enum An `enum` (enumeration) in Java is a specialized class type used to define a collection of unchangeable, compile-time constants. Under the hood, every enum implicitly extends the `java.lang.Enum` abstract class. Because Java does not support multiple inheritance for classes, an enum cannot extend another class, though it can implement multiple interfaces. ## Basic Syntax The simplest form of an enum is a comma-separated list of identifiers. By convention, enum constants are written in uppercase because they are implicitly `public static final`. ```java theme={"dark"} public enum ThreadState { NEW, RUNNABLE, BLOCKED, WAITING, TERMINATED } ``` ## Internal Mechanics When the Java compiler processes an enum, it translates it into a class. According to the Java Language Specification (JLS §8.9), an enum declaration is implicitly `final` *unless* it contains at least one enum constant with a class body, in which case it is implicitly `abstract`. Each declared constant becomes a static instance of that class. Conceptually, the compiler generates code similar to the following for a standard, implicitly `final` enum: ```java theme={"dark"} // Conceptual representation of compiled ThreadState enum public final class ThreadState extends java.lang.Enum { public static final ThreadState NEW = new ThreadState("NEW", 0); public static final ThreadState RUNNABLE = new ThreadState("RUNNABLE", 1); // ... private ThreadState(String name, int ordinal) { super(name, ordinal); } } ``` ## Fields, Constructors, and Methods Because enums are fully-fledged classes, they can encapsulate state and behavior. You can define instance fields, methods, and constructors within an enum. Enum constructors are strictly `private`. According to the Java Language Specification, if no access modifier is provided, the constructor is implicitly `private`. It is a compile-time error to use any access modifier other than `private`. The JVM invokes the constructor automatically during class *initialization* (when the static `` block is executed), not during class *loading*. You cannot instantiate an enum using the `new` keyword. ```java theme={"dark"} public enum HttpResponse { OK(200, "Success"), NOT_FOUND(404, "Resource not found"), INTERNAL_ERROR(500, "Server failure"); private final int statusCode; private final String message; // Implicitly private constructor HttpResponse(int statusCode, String message) { this.statusCode = statusCode; this.message = message; } public int getStatusCode() { return statusCode; } public String getMessage() { return message; } } ``` ## Constant-Specific Class Bodies Enums support polymorphism at the constant level. You can declare an `abstract` method in the enum type and provide a concrete implementation for each constant. The compiler handles this by creating anonymous inner classes for each constant. Because this enum contains constants with class bodies, the compiler implicitly marks the `ArithmeticOperation` enum class as `abstract` rather than `final`. ```java theme={"dark"} public enum ArithmeticOperation { ADD { @Override public double execute(double x, double y) { return x + y; } }, SUBTRACT { @Override public double execute(double x, double y) { return x - y; } }; public abstract double execute(double x, double y); } ``` ## Switch Statements and Expressions Java provides native support for enums in `switch` constructs. The compiler infers the enum type, allowing the use of unqualified constant names directly in the `case` labels. This applies to both traditional `switch` statements and modern `switch` expressions. ```java theme={"dark"} ThreadState state = ThreadState.NEW; // Switch expression String description = switch (state) { case NEW -> "Thread is created but not started"; case RUNNABLE -> "Thread is executing"; case BLOCKED, WAITING -> "Thread is suspended"; case TERMINATED -> "Thread has finished execution"; }; ``` ## Specialized Collections: EnumSet and EnumMap The `java.util` package provides highly optimized collection implementations specifically designed for enum types, avoiding the overhead of standard collections: * **`EnumSet`**: A `Set` implementation represented internally as a bit-vector. It is extremely compact and efficient, allowing bulk operations (like union or intersection) to execute using bitwise arithmetic. * **`EnumMap`**: A `Map` implementation where all keys must come from a single enum type. It is represented internally as an array, providing constant-time performance for lookups and insertions without the hashing overhead of a `HashMap`. ```java theme={"dark"} // EnumSet syntax EnumSet activeStates = EnumSet.of(ThreadState.NEW, ThreadState.RUNNABLE); // EnumMap syntax EnumMap stateDescriptions = new EnumMap<>(ThreadState.class); stateDescriptions.put(ThreadState.NEW, "Starting up"); ``` ## Built-in Methods The Java compiler and the `java.lang.Enum` base class provide several inherent methods to all enums: * `values()`: A static method injected by the compiler that returns an array containing all the constants of the enum in the order they are declared. * `valueOf(String name)`: A static method injected by the compiler that returns the enum constant matching the exact string provided. Throws an `IllegalArgumentException` if no match is found. * `name()`: A `final` method that returns the exact identifier of the enum constant as a string. * `ordinal()`: A `final` method that returns the zero-based integer position of the constant in the enum declaration. ## JVM Guarantees * **Serialization:** Enums handle serialization natively. The JVM guarantees that deserialized enum constants yield the exact same instance as the one residing in memory, preventing duplicate instances. * **Thread Safety:** The instantiation of enum constants during class initialization is guaranteed to be thread-safe by the JVM. * **Comparison:** Because the JVM ensures only one instance of each enum constant exists, they can be safely compared using the `==` operator instead of the `.equals()` method.

Tired of Poor Java Skills? Fix That With Deep Grasping! Learn More