Enums

What an enum really is

An enum is a class. Each constant is an object.

public enum Status { ACTIVE, RESERVE, RETIRED }

Java turns that into roughly this:

public final class Status extends Enum<Status> {
    public static final Status ACTIVE  = new Status("ACTIVE", 0);
    public static final Status RESERVE = new Status("RESERVE", 1);
    public static final Status RETIRED = new Status("RETIRED", 2);

    private Status(String name, int ordinal) { ... }    // private: nothing else can create one
}

Everything follows from that.

• Each constant is a public static final object, created during enum class initialization. This is the pairing from Section 6.4.
• The class is final, so nothing can extend it.
• The constructor is private, so nothing can create a fourth instance.
• It extends java.lang.Enum, which is where name(), ordinal(), compareTo() and a correct equals() come from.

Which is why == is safe here

if (status == Status.ACTIVE) { }        // correct, and preferred
if (status.equals(Status.ACTIVE)) { }   // also correct, and worse

There is one object per constant, guaranteed by the language. Comparing reference identity gives the right answer by construction, not by luck.

== is also better than equals here, for two reasons. It cannot throw a NullPointerException when status is null. And it is type checked, so comparing a Status with a Direction will not compile. equals would happily return false.

Enums can carry data and behaviour

This is where enums become powerful, and where most people stop learning about them.

public enum Status {
    ACTIVE("On duty", true, 1.0),
    RESERVE("Standing by", true, 0.5),
    RETIRED("Out of service", false, 0.0);

    private final String label;
    private final boolean deployable;
    private final double readinessFactor;

    Status(String label, boolean deployable, double readinessFactor) {
        this.label = label;
        this.deployable = deployable;
        this.readinessFactor = readinessFactor;
    }

    public String getLabel()          { return label; }
    public boolean isDeployable()     { return deployable; }
    public double effective(double r) { return r * readinessFactor; }
}

if (unit.getStatus().isDeployable()) { }

Look at what that removed. The rule about which statuses can deploy is no longer scattered across if statements in five files. It lives with the status, once.

Each constant can behave differently

You can go further and give a constant its own implementation:

public enum Operation {
    PLUS  { public int apply(int a, int b) { return a + b; } },
    MINUS { public int apply(int a, int b) { return a - b; } },
    TIMES { public int apply(int a, int b) { return a * b; } };

    public abstract int apply(int a, int b);
}

System.out.println(Operation.TIMES.apply(3, 4));    // 12

Each constant is an anonymous subclass, which is Section 7.4 appearing where you would not expect it. This is often cleaner than a switch, because adding a constant forces you to supply the behaviour rather than remembering to update a switch elsewhere.

The built-in methods

for (Status s : Status.values()) {
    System.out.println(s + ": " + s.getLabel());
}

EnumMap and EnumSet

When the key of a map is an enum, Java has a much better implementation than HashMap.

Map<Status, Integer> counts = new EnumMap<>(Status.class);

EnumMap is an array, indexed by ordinal. No hashing, no buckets, no collisions, and it uses less memory. EnumSet is a bit vector, one bit per constant, exactly the flags idea from the Section 3.1 exercises.

Both are faster and smaller than the general purpose versions. Phase X covers them properly, but the rule is simple: if your key is an enum, use EnumMap.

The singleton, done right

public enum Registry {
    INSTANCE;

    private final Map<Integer, String> units = new HashMap<>();
    public void register(int id, String name) { units.put(id, name); }
}

Registry.INSTANCE.register(101, "Atlas");

Most people consider this the best way to write a singleton in Java. Exactly one instance, guaranteed by the language rather than by careful coding. It is safe when several threads start at once, and it cannot be broken by serialization or reflection, both of which defeat the hand-written versions.