Java Enums

enum Size { SMALL, MEDIUM, LARGE }

Size mine = Size.MEDIUM;
if (mine == Size.MEDIUM) {
    System.out.println("Medium it is");
}

• The constants are written in CAPITALS by convention, separated by commas.
• Use them as TypeName.CONSTANT.
• Compare enum values with ==. Each constant exists exactly once, so == is safe and fast.
• An enum can sit in its own file, like a class, or inside another class.

Every enum automatically gets these methods:

valueOf throws an IllegalArgumentException if the text doesn't match exactly, including capitals, so handle that when converting user input. Avoid storing ordinal() in files or databases: reordering the constants later would change every number.

Enums and switch are a perfect pair. Inside the switch, write the constants without the type name:

String label = switch (status) {
    case PENDING -> "Waiting for payment";
    case PAID, SHIPPED -> "On its way";
    case DELIVERED -> "Arrived";
};

When a switch expression covers every constant, no default is needed. Better still, if someone later adds a new constant such as RETURNED, the compiler reports every switch expression that doesn't handle it, so nothing is forgotten.

Constants can carry data. Add fields, a constructor and methods after the list, which then ends with a semicolon:

enum Planet {
    MERCURY(3.7), EARTH(9.8), MARS(3.7);

    private final double gravity;

    Planet(double gravity) { this.gravity = gravity; }

    double weightOf(double massKg) { return massKg * gravity; }
}

The value in brackets after each constant is passed to the constructor. An enum's constructor is always private: you can't create new constants with new. Java also offers EnumMap and EnumSet, very fast maps and sets designed for enum keys.

An enum can declare an abstract method and give each constant its own body, so the behaviour lives right next to the constant instead of in a switch elsewhere:

enum Operation {
    ADD {
        int apply(int a, int b) { return a + b; }
    },
    MULTIPLY {
        int apply(int a, int b) { return a * b; }
    };

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

Operation.MULTIPLY.apply(3, 4) returns 12. A new constant can't be added without its own apply body, because the compiler insists on it. Enums can also implement interfaces, which is useful when an enum needs to fit an existing contract such as Comparator or your own Describable. For simple data, the field-and-constructor style above stays shorter; reach for constant-specific bodies when the logic genuinely differs. More advanced patterns are in the enum constructors lesson.