Преимущества перечисления Java по сравнению со старым шаблоном Typesafe Enum?

• «не может быть разделено на подклассы» не является ограничением. Это одно из больших преимуществ: он гарантирует, что всегда будет только тот набор значений, который определен в enum, и не более!
• enum правильно обрабатывает сериализацию. Вы можете сделать это и с типобезопасными перечислениями, но об этом часто забывают (или просто не знают). Это гарантирует, что e1.equals(e2) всегда подразумевает e1 == e2 для любых двух enum значений e1 и e2 (и наоборот, что, вероятно, более важно).
• Существуют определенные облегченные структуры данных, которые обрабатывают перечисления: EnumSet и EnumMap (украдены из этого ответа )

Конечно, есть много преимуществ, которые другие люди упомянут здесь в качестве ответов. Самое главное, вы можете писать enums очень быстро, и они делают много вещей, например, реализуют Serializable, Comparable, equals(), toString(), hashCode() и т. Д., Которые вы не включили в свое перечисление.

Но я могу показать вам серьезный недостаток enum (IMO). Вы не только не можете наследовать их по своему желанию, но и не можете снабдить их универсальным параметром. Когда можно было написать это:

// A model class for SQL data types and their mapping to Java types
public class DataType<T> {
    private final String name;
    private final Class<T> type;

    public static final DataType<Integer> INT      = new DataType<Integer>("int", Integer.class);
    public static final DataType<Integer> INT4     = new DataType<Integer>("int4", Integer.class);
    public static final DataType<Integer> INTEGER  = new DataType<Integer>("integer", Integer.class);
    public static final DataType<Long>    BIGINT   = new DataType<Long>("bigint", Long.class);    

    private DataType(String name, Class<T> type){
        this.name = name;
        this.type = type;
    }

    // Returns T. I find this often very useful!
    public T parse(String string) throws Exception {
        // [...]
    }
}

class Utility {

    // Enums equipped with generic types...
    public static <T> T doStuff(DataType<T> type) {
        return ...
    }
}

Это невозможно с перечислением:

// This can't be done
public enum DataType<T> {

    // Neither can this...
    INT<Integer>("int", Integer.class), 
    INT4<Integer>("int4", Integer.class), 

    // [...]
}

Теперь в JDK1.5 + "официальный" способ, очевидно, использовать enum:

public enum Suit {
  CLUBS("clubs"), DIAMONDS("diamonds"), HEARTS("hearts"), SPADES("spades");

  private final String name;

  private Suit(String name) {
    this.name = name;
  }
}

На самом деле это больше похоже на

 public enum Suit {
     CLUBS, DIAMONDS, HEARTS, SPADES;
 }

потому что перечисления уже предоставляют name() метод. Кроме того, они предоставляют метод ordinal() (который позволяет использовать эффективные структуры данных, такие как EnumSet и EnumMap), реализуют Serializable, переопределяют toString, предоставляют values() и valueOf(String name). Их можно использовать в операторе переключения, безопасном для типов, и они являются одиночными.

Ваша реализация типобезопасного перечисления немного упрощена. Когда вы будете иметь дело с сериализацией, все станет намного сложнее.

Java enums решает проблему с сериализацией / десериализацией. Гарантируется, что enum уникальность, и вы можете сравнить их с оператором ==.

Прочтите соответствующие главы в Effective Java 2nd Edition (об использовании перечислений вместо синглетонов, об использовании EnumSets и т. Д.).

EnumSet и _ 2_ - это настраиваемые структуры данных, построенные на основе определенных функций перечислений. У них есть удобные дополнительные функции, и они очень быстрые. Для них нет эквивалента (по крайней мере, с такой же элегантностью использования, см. Комментарии) без перечислений.

Кроме того:

Перечисления JDK5 можно легко использовать в операторах switch-case с хорошей поддержкой IDE.

Suit suit = ...; 
switch (suit) { 
    case SPADES: System.out.println("Motorhead!"); break;
    default: System.out.println("Boring ..");
}

Сам по себе синтаксический сахар стоит того :-P В конце концов, это тоже для (:).

А если серьезно, тот факт, что автоматически используются name () и ordinal () из коробки, для их перечисления, использования в switch (), для присоединения к ним дополнительных значений, является для них хорошими аргументами: это позволяет избежать большого количества шаблонного кода. .

Традиционная ленивая альтернатива, использующая целые числа, небезопасна для типов и гораздо более ограничена. Недостатком перечислений по сравнению с этой альтернативой является то, что они больше не являются легковесными.