Java enumerations, introduced in JDK 1.5 via the enum keyword, provide a type-safe way to define fixed sets of constants.

Core Concepts

A basic enumeration is declared as follows:

enum PrimaryColor { RED, GREEN, BLUE }

If no explicit values are assigned, the constants are automatically assigned ordinal values starting from zero. For PrimaryColor, this results in RED=0, GREEN=1, BLUE=2.

Enumerations are ideal for grouping related constants, such as error codes or state machine states, enhancing code clarity and manageability.

The Nature of Enums

An enum is a specialized class that inherits from java.lang.Enum. This base class implements the Comparable and Serializable interfaces.

Enumeration Methods

The Enum class provides several useful methods:

• values(): Returns an array of all enum constants in the order they were declared.
• name(): Returns the name of the constant as declared.
• ordinal(): Returns the positioanl index of the constant.
• getDeclaringClass(): Returns the Class object of the enum type.
• equals(): Checks object equality.

Enum constants can be compared using the == operator.

Example: Demonstrating Enum Methods

public class EnumMethodExample {
    enum Status { PENDING, ACTIVE, INACTIVE }
    enum Priority { LOW, MEDIUM, HIGH }

    public static void main(String[] args) {
        System.out.println("=== Status Values ===");
        for (Status s : Status.values()) {
            System.out.println(s + " ordinal: " + s.ordinal());
        }
        System.out.println("=== Priority Values ===");
        for (Priority p : Priority.values()) {
            System.out.println(p + " ordinal: " + p.ordinal());
        }

        Status active = Status.ACTIVE;
        System.out.println("active name(): " + active.name());
        System.out.println("active getDeclaringClass(): " + active.getDeclaringClass());
        System.out.println("active hashCode(): " + active.hashCode());
        System.out.println("active compareTo Status.ACTIVE: " + active.compareTo(Status.ACTIVE));
        System.out.println("active equals Status.ACTIVE: " + active.equals(Status.ACTIVE));
        System.out.println("active equals Priority.MEDIUM: " + active.equals(Priority.MEDIUM));
        System.out.println("active == Status.INACTIVE: " + (active == Status.INACTIVE));
    }
}

Enum Features and Customization

Enums can be treated like regular classes, with the exception that they cannot inherit from another class. They can have fields, constructors, and methods.

Adding Fields and Methods

Unlike C/C++, Java enums cannot be assigned explicit values using =. Instead, values are provided through constructors.

Example: Enum with Custom Fields and Methods

public enum OperationStatus {
    SUCCESS(0, "Operation completed successfully"),
    FAILURE(1, "Operation failed"),
    PENDING(2, "Operation in progress");

    private final int code;
    private final String message;

    OperationStatus(int statusCode, String statusMessage) {
        this.code = statusCode;
        this.message = statusMessage;
    }

    public int getStatusCode() {
        return code;
    }

    public String getStatusMessage() {
        return message;
    }
}

If an enum contains methods or fields, the constant list must end with a semicolon. Constants must be declared before any methods or fields.

Implementing Interfaces

Enums can implement interfaces, allowing them to adhere to a specific contract.

Example: Enum Implementing an Interface

public interface Coded {
    int getCode();
    String getDescription();
}

public enum ErrorCode implements Coded {
    OK(0, "No error"),
    INVALID_INPUT(100, "Invalid user input"),
    SERVER_ERROR(200, "Internal server error");

    private final int errorCode;
    private final String errorDescription;

    ErrorCode(int code, String description) {
        this.errorCode = code;
        this.errorDescription = description;
    }

    @Override
    public int getCode() {
        return errorCode;
    }

    @Override
    public String getDescription() {
        return errorDescription;
    }
}

Use Cases

Organizing Constants

Enums provide a structured and type-safe alternative to groups of public static final constants.

Switch Statements

Enums work seamlessly with switch statements, improving readability.

enum TrafficLight { RED, YELLOW, GREEN }

public static String getInstruction(TrafficLight light) {
    String instruction = "Signal malfunction";
    switch (light) {
        case RED:
            instruction = "Stop";
            break;
        case YELLOW:
            instruction = "Caution";
            break;
        case GREEN:
            instruction = "Go";
            break;
    }
    return instruction;
}

Grouping Enums

Related enums can be grouped within an interface or a class. When grouped within an interface, the enums are implicitly public static.

Example: Enums Grouped in an Interface

public interface Categories {
    enum Hardware { CPU, RAM, SSD }
    enum Software { OS, DATABASE, APPLICATION }
}

Strategy Enum Pattern

A powerful pattern involves using an enum within an enum to define different behaviors or strategies.

Example: Strategy Enum for Pay Calculation

enum PayrollDay {
    MONDAY(WorkType.WEEKDAY), TUESDAY(WorkType.WEEKDAY),
    WEDNESDAY(WorkType.WEEKDAY), THURSDAY(WorkType.WEEKDAY),
    FRIDAY(WorkType.WEEKDAY), SATURDAY(WorkType.WEEKEND),
    SUNDAY(WorkType.WEEKEND);

    private final WorkType workType;
    private static final int STANDARD_HOURS = 8;

    PayrollDay(WorkType type) {
        this.workType = type;
    }

    public double calculatePay(double hoursWorked, double hourlyRate) {
        return workType.calculatePay(hoursWorked, hourlyRate, STANDARD_HOURS);
    }

    private enum WorkType {
        WEEKDAY {
            @Override
            double calculateOvertimePay(double hours, double rate, int standard) {
                return hours > standard ? (hours - standard) * rate * 0.5 : 0;
            }
        },
        WEEKEND {
            @Override
            double calculateOvertimePay(double hours, double rate, int standard) {
                return hours * rate * 0.5;
            }
        };

        abstract double calculateOvertimePay(double hrs, double rt, int std);

        double calculatePay(double totalHours, double hourlyRate, int standardHours) {
            double basePay = totalHours * hourlyRate;
            return basePay + calculateOvertimePay(totalHours, hourlyRate, standardHours);
        }
    }
}

EnumSet and EnumMap

Java provides EnumSet and EnumMap for high-performance operations with enums.

• EnumSet: A high-performance Set implementation for enum types.
• EnumMap: A specialized, efficient Map implementation where keys are enum constants.

Example: Using EnumSet and EnumMap

// Using EnumSet
EnumSet<ErrorCode> allErrors = EnumSet.allOf(ErrorCode.class);
for (ErrorCode err : allErrors) {
    System.out.println(err.name() + " : " + err.ordinal());
}

// Using EnumMap
EnumMap<TrafficLight, String> signalMap = new EnumMap<>(TrafficLight.class);
signalMap.put(TrafficLight.RED, "Stop");
signalMap.put(TrafficLight.YELLOW, "Prepare to stop");
signalMap.put(TrafficLight.GREEN, "Proceed");

for (Map.Entry<TrafficLight, String> entry : signalMap.entrySet()) {
    System.out.println(entry.getKey() + " : " + entry.getValue());
}