Enums in Java

An enum (short for enumeration) is a special Java type that represents a fixed set of named constants — think days of the week, directions, or order statuses. Unlike a plain set of int or String constants, an enum in Java is a full class: it can have its own constructor, fields, and methods, and every enum implicitly extends java.lang.Enum.

Because enum values are known and fixed at compile time, the compiler can catch mistakes that plain constants cannot — passing an invalid value simply cannot happen, because no such enum constant exists to pass. This makes enums one of the simplest ways to make Java code both safer and more self-documenting.

Why it matters

Order statuses, user roles and plan types have a fixed set of values, and representing them as strings or integers invites typos and invalid values that the compiler cannot catch. Java enums are full classes, so each constant can carry data and behaviour, which removes a great many if chains.

Enums as Special Classes

Declaring enum Day { MONDAY, TUESDAY, ... } creates a class with exactly those named, singleton instances — Day.MONDAY is not just a label, it is a real object, and it is always the same object every time it's referenced (enum constants are inherently singletons and safe to compare with ==). Every enum automatically inherits useful methods: name() returns the constant's exact declared name, and ordinal() returns its position (starting at 0) in the declaration.

Adding Fields, Constructors, and Methods

Enums become genuinely powerful once you attach data and behavior to each constant. You give the enum a private field and a constructor, and then supply constructor arguments after each constant's name. Each constant can also override methods individually if needed, but most commonly they share methods defined once on the enum type, using each constant's own field values.

values(), valueOf(), and switch

Every enum automatically gets a static values() method that returns an array of all constants in declaration order — ideal for looping over every possible value. valueOf(String) converts a matching String back into the corresponding constant, throwing IllegalArgumentException if the name doesn't match exactly. Enums also work naturally in a switch statement or expression, where you reference the bare constant name (without the enum type prefix) in each case label.

• EnumType.values() — returns all constants as an array, in declaration order.
• EnumType.valueOf("NAME") — parses a String into the matching constant, or throws if none matches.
• constant.name() and constant.ordinal() — the declared name and zero-based position.

Examples

public class EnumBasicsDemo {

    enum Day { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY }

    static boolean isWeekend(Day day) {
        switch (day) {
            case SATURDAY:
            case SUNDAY:
                return true;
            default:
                return false;
        }
    }

    public static void main(String[] args) {
        Day today = Day.SATURDAY;
        System.out.println(today + " is weekend: " + isWeekend(today));

        for (Day d : Day.values()) {
            System.out.print(d.ordinal() + ":" + d + " ");
        }
        System.out.println();

        Day parsed = Day.valueOf("FRIDAY");
        System.out.println("Parsed: " + parsed);
    }
}

SATURDAY is weekend: true
0:MONDAY 1:TUESDAY 2:WEDNESDAY 3:THURSDAY 4:FRIDAY 5:SATURDAY 6:SUNDAY
Parsed: FRIDAY

public class EnumWithFieldsDemo {

    enum Planet {
        MERCURY(3.303e+23, 2.4397e6),
        VENUS(4.869e+24, 6.0518e6),
        EARTH(5.976e+24, 6.37814e6);

        private final double mass;   // kilograms
        private final double radius; // meters

        Planet(double mass, double radius) {
            this.mass = mass;
            this.radius = radius;
        }

        double surfaceGravity() {
            final double G = 6.67300E-11;
            return G * mass / (radius * radius);
        }
    }

    public static void main(String[] args) {
        for (Planet p : Planet.values()) {
            System.out.printf("%-8s gravity: %.2f m/s^2%n", p, p.surfaceGravity());
        }
    }
}

MERCURY  gravity: 3.70 m/s^2
VENUS    gravity: 8.87 m/s^2
EARTH    gravity: 9.80 m/s^2

Exercise

Define an enum Plan with the constants FREE, PRO and TEAM, each holding a monthly price of 0, 499 and 1999, and a method yearly() that returns twelve times the price. Print the yearly price of the plan named by the string PRO, then the name and monthly price of every plan that is not free.

Expected output: 5988, PRO 499, TEAM 1999 (one per line)

// TODO: enum Plan with a price field, a constructor and yearly()

public class Plans {
    public static void main(String[] args) {
        // TODO: look up the plan named "PRO" and print its yearly price

        // TODO: loop over all plans, printing "NAME price" for those with a price above 0
    }
}

enum Plan {
    FREE(0),
    PRO(499),
    TEAM(1999);

    private final int price;

    Plan(int price) {
        this.price = price;
    }

    int price() {
        return price;
    }

    int yearly() {
        return price * 12;
    }
}

public class Plans {
    public static void main(String[] args) {
        System.out.println(Plan.valueOf("PRO").yearly()); // 5988

        for (Plan plan : Plan.values()) {
            if (plan.price() > 0) {
                System.out.println(plan + " " + plan.price()); // PRO 499, TEAM 1999
            }
        }
    }
}

Quick quiz

Interview questions