Java 的枚举相对于旧的“类型安全枚举”模式的优势？

Question

在 JDK1.5 之前的 Java 中，“Typesafe Enum”模式是实现只能采用有限数量值的类型的常用方法：

public class Suit {
    private final String name;

    public static final Suit CLUBS =new Suit("clubs");
    public static final Suit DIAMONDS =new Suit("diamonds");
    public static final Suit HEARTS =new Suit("hearts");
    public static final Suit SPADES =new Suit("spades");    

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

（参见例如 Bloch 的 Effective Java 中的第 21 项）。

现在在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;
  }
}

显然，语法更好更简洁（无需显式定义值的字段，提供合适的toString()），但到目前为止enum 看起来非常像Typesafe Enum 模式。

我知道的其他差异：

• 枚举自动提供values() 方法
• 枚举可用于switch()（编译器甚至会检查您是否忘记了某个值）

但这一切看起来只不过是语法糖，甚至还有一些限制（例如，enum 总是继承自 java.lang.Enum，并且不能被子类化）。

enum 提供的其他更基本的好处是否无法通过 Typesafe Enum 模式实现？

Answer 1

现在在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)。它们可以在类型安全的 switch 语句中使用，并且是单例。

Answer 2

语法糖本身就物有所值：-P 毕竟，对于 ( : ) 也是如此。

但是说真的，开箱即用的自动 name() 和 ordinal()、枚举它们、在 switch() 中使用它们、为它们附加附加值的事实对它们来说是很好的论据：它避免了很多样板代码。

使用 int 的传统惰性替代方法不是类型安全的，而且受到更多限制。 与这种替代方法相比，枚举的一个缺点是它们不再是轻量级的。

Answer 3

另外：

JDK5 枚举可以轻松用于具有良好 IDE 支持的 switch-case 语句

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

Answer 4

当然，其他人会在这里提到很多优点作为答案。最重要的是，您可以非常快速地编写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), 

    // [...]
}

Answer 5

EnumSet 和EnumMap 是围绕枚举的特定特性构建的自定义数据结构。它们有方便的额外功能，而且速度非常快。没有枚举，就没有等价物（至少没有等价的使用优雅，请参阅 cmets）。

Answer 6

您的类型安全枚举实现有点过于简单。当您处理序列化时，它会变得更加复杂。

Java enums 解决了序列化/反序列化的问题。 enum 保证是唯一的，您可以将它们与 == 运算符进行比较。

阅读 Effective Java 2nd Edition 中的相应章节（关于使用枚举而不是单例，关于使用 EnumSets 等）。

Answer 7

• “不能被子类化”不是限制。这是一大优势：它确保始终只有在 enum 中定义的一组值，仅此而已！
• enum 正确处理序列化。您可以使用类型安全的枚举来做到这一点，但它经常被遗忘（或根本不知道）。这确保了e1.equals(e2) 总是 暗示e1 == e2 对任意两个enum 值e1 和e2（反之亦然，这可能更重要）。
• 有一些特定的轻量级数据结构可以处理枚举：EnumSet 和 EnumMap（从 this answer 窃取）