Unlock Java’s Powerful Enum Features: From Basics to Functional Programming

Java enums are more powerful than you might think; they provide a type‑safe way to represent a fixed set of values while offering the full capabilities of a class.

When I first encountered enums, I assumed they were merely named constants that could be replaced by static final strings, but I was wrong. Java enums have advanced features that keep code clean, less error‑prone, and highly expressive.

Enums Are Classes

In Java, every enum implicitly extends java.lang.Enum<E>, which is an abstract class implementing Constable, Comparable<E>, and Serializable. The simplified source looks like this:

public abstract class Enum<E extends Enum<E>> implements Constable, Comparable<E>, Serializable {
    private final String name;
    public final String name() { return name; }
    private final int ordinal;
    public final int ordinal() { return ordinal; }
    protected Enum(String name, int ordinal) { this.name = name; this.ordinal = ordinal; }
    public String toString() { return name; }
    public final boolean equals(Object other) { return this == other; }
    public final int hashCode() { return super.hashCode(); }
    public final int compareTo(E o) {
        Enum<?> other = (Enum<?>) o;
        Enum<E> self = this;
        if (self.getClass() != other.getClass() && self.getDeclaringClass() != other.getDeclaringClass())
            throw new ClassCastException();
        return self.ordinal - other.ordinal;
    }
}

This shows that an enum is essentially an abstract class with two fields: name and ordinal. Enums can therefore have instance methods, constructors, and additional fields, but they cannot override hashCode() or equals(Object).

Basic Enum Example

Consider a simple enum representing arithmetic operations:

enum Operation {
    ADD,
    SUBTRACT,
    MULTIPLY
}

A typical implementation would use a switch statement:

public int apply(Operation operation, int arg1, int arg2) {
    switch (operation) {
        case ADD: return arg1 + arg2;
        case SUBTRACT: return arg1 - arg2;
        case MULTIPLY: return arg1 * arg2;
        default: throw new UnsupportedOperationException();
    }
}

This approach has two drawbacks: adding a new enum constant does not trigger a compile‑time error for the missing case, and the default clause is required even though it should never be reached.

Refactoring to Instance Method

We can move the switch inside the enum and turn it into an instance method:

enum Operation {
    ADD,
    SUBTRACT,
    MULTIPLY;
    public int apply(int a, int b) {
        switch (this) {
            case ADD: return a + b;
            case SUBTRACT: return a - b;
            case MULTIPLY: return a * b;
            default: throw new UnsupportedOperationException();
        }
    }
}

Now the call becomes Operation.ADD.apply(2, 3), but the switch is still present.

Functional Enum Implementation

Java 8 allows us to store a function in each enum constant, eliminating the switch entirely:

enum Operation {
    ADD((x, y) -> x + y),
    SUBTRACT((x, y) -> x - y),
    MULTIPLY((x, y) -> x * y);

    private final BiFunction<Integer, Integer, Integer> operation;

    Operation(BiFunction<Integer, Integer, Integer> operation) {
        this.operation = operation;
    }

    public int apply(int x, int y) {
        return operation.apply(x, y);
    }
}

Key points of this approach:

Enum can have fields, constructors, and instance methods.

A field of type BiFunction<Integer, Integer, Integer> stores the operation.

Each constant supplies a lambda expression that implements the desired behavior.

The compiler forces you to handle every enum constant, preventing forgotten cases.

The full example, including a custom Adder class that implements BiFunction, can be found in the GitHub repository linked below.

GitHub: https://github.com/alex-power/java-enum-example

Reference: Advanced Java Enum Features You Need to Know