Introduction to Java Enums

Java enums are a special data type that allows for a variable to be a set of predefined constants. The values in an enum are implicitly final, static, and public. They provide type safety, making your code more readable and less prone to errors compared to using simple integer or string constants. Enums can have their own fields, constructors, and methods, offering a powerful way to represent a fixed set of related items.

Basic Enum Definition and Usage

The simplest form of an enum is a list of named constants. This is useful for representing a fixed set of options.

Defining a Simple Enum

Let's define an enum to represent the days of the week. Each day is a constant instance of the DayOfWeek type.

public enum DayOfWeek {
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
}

Using Enums in Control Flow

Enums are often used in switch statements, which provides a clean and type-safe way to handle different cases.

public class Scheduler {
    public void planActivity(DayOfWeek day) {
        switch (day) {
            case MONDAY:
                System.out.println("Start of the work week. Plan meetings.");
                break;
            case WEDNESDAY:
                System.out.println("Mid-week. Review project progress.");
                break;
            case FRIDAY:
                System.out.println("End of the work week. Prepare for the weekend.");
                break;
            case SATURDAY:
            case SUNDAY:
                System.out.println("Weekend! Time to relax.");
                break;
            default:
                System.out.println("Regular workday.");
        }
    }
}

Advanced Enums: Fields and Methods

Enums can be much more then just a list of names. They can contain fields, constructors, and methods, effectively behaving like a regular class.

Defining an Enum with Custom Data

Consider an enum for logging levels. Each level has a name and a severity code. We can define a private constructor to initialize these fields and provide getter methods.

public enum LogLevel {
    DEBUG("Debug", 1),
    INFO("Info", 2),
    WARN("Warning", 3),
    ERROR("Error", 4);

    private final String description;
    private final int severity;

    LogLevel(String description, int severity) {
        this.description = description;
        this.severity = severity;
    }

    public String getDescription() {
        return description;
    }

    public int getSeverity() {
        return severity;
    }

    public void log(String message) {
        System.out.println("[" + this.description + "] " + message);
    }
}

Utilizing Enum Methods

With the ehnanced LogLevel enum, we can now access its properties and invoke its methods directly on the enum constants.

public class Logger {
    public void record(LogLevel level, String message) {
        // Example logic to handle different severity levels
        if (level.getSeverity() >= 3) {
            System.err.println("High priority log: " + message);
        } else {
            System.out.println("Low priority log: " + message);
        }
        level.log(message);
    }
}