Перечисления (enum) в Java: фиксированный набор именованных констант

Фиксированный набор именованных значений

Некоторые значения имеют смысл только как элемент небольшого известного списка: дни недели, масти в колоде, состояния, в которых может находиться заказ. Их можно было бы смоделировать кодами int (0 — в ожидании, 1 — отправлено) или строками ("PENDING", "SHIPPED"), но ничто не мешает вызывающему передать 7 или "PNEDING". enum закрывает эту брешь — сам тип допускает только те значения, которые вы объявили.

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

public class Main {
    public static void main(String[] args) {
        Day today = Day.WEDNESDAY;
        System.out.println(today);          // WEDNESDAY
        System.out.println(today == Day.WEDNESDAY);
    }
}

Day — это совершенно новый тип. Переменная типа Day может хранить ровно одну из этих семи констант (или null) и ничего больше. Компилятор отвергнет Day d = "WEDNESDAY"; или Day d = 2;. Именно эта гарантия и есть весь смысл.

Каждая константа (Day.MONDAY и так далее) — это единственный общий экземпляр, создаваемый один раз. Поскольку MONDAY всегда один, перечисления сравнивают через ==, а не через equals — это один и тот же объект.

switch по перечислению

Перечисления естественно сочетаются со switch. Внутри switch не нужно даже уточнять каждую константу именем типа:

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

public class Main {
    static String kind(Day d) {
        switch (d) {
            case SATURDAY:
            case SUNDAY:
                return "weekend";
            default:
                return "weekday";
        }
    }

    public static void main(String[] args) {
        System.out.println(kind(Day.SATURDAY));
        System.out.println(kind(Day.MONDAY));
    }
}

Внутри switch пишите case SATURDAY, а не case Day.SATURDAY — Java сама выводит тип. Главное преимущество перед switch по строке или int в том, что если позже вы добавите новую константу, IDE и проверки полноты смогут указать на каждый switch, который забыл её обработать.

Перебор всех констант

Каждое перечисление автоматически получает статический метод values(), возвращающий все его константы в порядке объявления, а также ordinal(), дающий позицию каждой константы, начиная с нуля:

enum Suit { HEARTS, DIAMONDS, CLUBS, SPADES }

public class Main {
    public static void main(String[] args) {
        for (Suit s : Suit.values()) {
            System.out.println(s.ordinal() + " -> " + s.name());
        }
    }
}

name() возвращает идентификатор константы в виде String, а values() идеально подходит для построения меню или перебора вариантов. Предостережение: не сохраняйте ordinal() нигде, где данные хранятся постоянно. Если кто-то позже переупорядочит константы, номера сдвинутся, и ваши сохранённые данные сломаются. Считайте ordinal() деталью реализации, а не стабильным идентификатором.

Перечисления — настоящие классы: поля и методы

Именно здесь перечисления Java выходят за рамки enum с именованными целыми числами из других языков. Каждая константа может нести данные, передаваемые через конструктор, и у перечисления могут быть методы. Сначала вы перечисляете константы, даёте каждой её аргументы конструктора, а затем после точки с запятой объявляете поля, конструктор и методы.

enum Planet {
    MERCURY(3.303e23, 2.4397e6),
    EARTH(5.976e24, 6.37814e6);

    private final double mass;     // килограммы
    private final double radius;   // метры

    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 class Main {
    public static void main(String[] args) {
        for (Planet p : Planet.values()) {
            System.out.printf("%s gravity: %.2f%n", p, p.surfaceGravity());
        }
    }
}

Обратите внимание на структуру: сначала идут константы и заканчиваются точкой с запятой, а затем следует остальная часть класса. Конструктор неявно private — вы никогда не сможете написать new Planet(...), потому что единственно допустимые экземпляры — это объявленные сверху. Поля final делают каждую константу неизменяемой, что и нужно для общих синглтонов.

Из строки и обратно

Чтобы превратить строку в соответствующую константу, используйте автоматически сгенерированный valueOf:

enum Status { PENDING, SHIPPED, DELIVERED }

public class Main {
    public static void main(String[] args) {
        Status s = Status.valueOf("SHIPPED");
        System.out.println(s == Status.SHIPPED);   // true

        try {
            Status bad = Status.valueOf("shipped"); // регистр имеет значение!
            System.out.println(bad);
        } catch (IllegalArgumentException e) {
            System.out.println("no constant named 'shipped'");
        }
    }
}

valueOf сопоставляет имя константы точно, с учётом регистра, и бросает IllegalArgumentException, если совпадения нет. Это и есть распространённая ловушка: "shipped" не совпадает с SHIPPED. При разборе пользовательского ввода или внешних данных сначала приведите регистр к нужному (input.toUpperCase()) и оберните вызов в try/catch, иначе программа упадёт на первом же неверном значении.

Поведение для каждой константы

Иногда каждой константе нужно вести себя по-разному, а не просто хранить разные данные. Вы можете дать перечислению абстрактный метод и заставить каждую константу предоставить собственную реализацию в небольшом теле:

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);
}

public class Main {
    public static void main(String[] args) {
        for (Operation op : Operation.values()) {
            System.out.println(op + ": " + op.apply(6, 2));
        }
    }
}

Это иногда называют шаблоном «метода, специфичного для константы». Он заменяет разросшийся switch по константе поведением, прикреплённым прямо к каждой из них — добавьте новую операцию, и компилятор заставит вас определить её apply, так что ни один случай не забудется.

Когда стоит использовать перечисление

Используйте enum всякий раз, когда значение естественно является элементом небольшого, фиксированного, известного на этапе компиляции набора:

• Состояния в рабочем процессе (PENDING, SHIPPED, DELIVERED).
• Категории, режимы или типы (READ, WRITE, EXECUTE).
• Везде, где у вас был соблазн объявить группу констант public static final int — перечисление даёт те же именованные значения плюс типобезопасность, читаемый toString и поддержку switch в придачу.

Не используйте enum для открытого или определяемого во время выполнения набора (имена пользователей, список стран из базы данных). Перечисления фиксируются на этапе компиляции; если набор меняется во время работы программы, вам нужна обычная коллекция.

Далее: Обобщения (generics)

Вы уже видели, как values() возвращает Planet[], а на предыдущих страницах — использование List<Shape>: этот синтаксис <...> и есть обобщения (generics), способ Java написать один класс или метод, который работает для многих типов, сохраняя полную типобезопасность. Дальше мы разберём, как на самом деле работают List<String> и Map<K, V> и как писать собственные обобщённые типы.