当一个变量(特别是一个方法参数)只能从一组可能的值中选取一个时，您应该始终使用枚举。例如类型常量(合约状态:“永久”，“临时”，“学徒”)或标志(“立即执行”，“延迟执行”)。

如果使用枚举而不是整数(或字符串代码)，则增加了编译时检查，避免了传入无效常量的错误，并且记录了哪些值是可以合法使用的。

顺便说一句，过度使用枚举可能意味着你的方法做了太多的事情(通常有几个单独的方法会更好，而不是一个方法有几个标记来修改它所做的事情)，但如果你必须使用标记或类型代码，枚举是最好的选择。

举个例子，哪个更好?

/** Counts number of foobangs.
 * @param type Type of foobangs to count. Can be 1=green foobangs,
 * 2=wrinkled foobangs, 3=sweet foobangs, 0=all types.
 * @return number of foobangs of type
 */
public int countFoobangs(int type)

与

/** Types of foobangs. */
public enum FB_TYPE {
 GREEN, WRINKLED, SWEET, 
 /** special type for all types combined */
 ALL;
}

/** Counts number of foobangs.
 * @param type Type of foobangs to count
 * @return number of foobangs of type
 */
public int countFoobangs(FB_TYPE type)

方法调用如下:

int sweetFoobangCount = countFoobangs(3);

然后就变成:

int sweetFoobangCount = countFoobangs(FB_TYPE.SWEET);

在第二个例子中，很明显哪些类型是允许的，文档和实现不能不同步，编译器可以强制执行这一点。 另外，无效调用

int sweetFoobangCount = countFoobangs(99);

已经不可能了。

从Java文档-

您应该在任何时候使用枚举类型 需要表示一个固定的集合 常量。包括自然enum 比如我们太阳系中的行星 你知道的系统和数据集 编译时所有可能的值 时间——例如，a上的选项 菜单、命令行标志等等。

一个常见的例子是用枚举类型替换一个类，用一组私有静态final int常量(常量数量合理)。基本上，如果你认为你在编译时知道“something”的所有可能值，你可以将其表示为枚举类型。比起带有常量的类，枚举提供了可读性和灵活性。

枚举类型几乎没有其他优点。它们总是特定枚举类的一个实例(因此出现了使用枚举作为单例的概念)。另一个优点是可以在switch-case语句中使用枚举作为类型。你也可以在枚举上使用toString()将它们打印为可读的字符串。

除了@BradB，回答:

That is so true... It's strange that it is the only answer who mention that. When beginners discover enums, they quickly take that as a magic-trick for valid identifier checking for the compiler. And when the code is intended to be use on distributed systems, they cry... some month later. Maintain backward compatibility with enums that contains non static list of values is a real concern, and pain. This is because when you add a value to an existing enum, its type change (despite the name does not).

"Ho, wait, it may look like the same type, right? After all, they’re enums with the same name – and aren’t enums just integers under the hood?" And for these reasons, your compiler will likely not flag the use of one definition of the type itself where it was expecting the other. But in fact, they are (in most important ways) different types. Most importantly, they have different data domains – values that are acceptable given the type. By adding a value, we’ve effectively changed the type of the enum and therefore break backward compatibility.

总之:当你想使用它的时候使用它，但是，请检查所使用的数据域是一个有限的、已知的、固定的集合。

在我看来，你到目前为止的所有答案都是正确的，但根据我的经验，我想用几句话来表达:

如果希望编译器检查标识符值的有效性，请使用枚举。

否则，您可以像往常一样使用字符串(可能您为应用程序定义了一些“约定”)，并且您将非常灵活……但是你不能在你的字符串上获得100%的安全，你只能在运行时意识到它们。

这里有很多答案，只想指出两个具体的:

1)在Switch-case语句中作为常量使用。 Switch case不允许使用String对象作为case。枚举可以派上用场。更多:http://www.javabeat.net/2009/02/how-to-use-enum-in-switch/

2)再次实现单例设计模式- Enum，来拯救。这里的用法:在Java中使用Enum作为单例的最佳方法是什么?

不管别人怎么说…在我曾经工作过的一个旧项目中，实体(独立应用程序)之间的大量通信使用代表一个小集合的整数。用静态方法将set声明为enum很有用，可以从value中获取enum object，反之亦然。代码看起来更干净，开关案例可用性和更容易写入日志。

enum ProtocolType {
    TCP_IP (1, "Transmission Control Protocol"), 
    IP (2, "Internet Protocol"), 
    UDP (3, "User Datagram Protocol");

    public int code;
    public String name;

    private ProtocolType(int code, String name) {
        this.code = code;
        this.name = name;
    }

    public static ProtocolType fromInt(int code) {
    switch(code) {
    case 1:
        return TCP_IP;
    case 2:
        return IP;
    case 3:
        return UDP;
    }

    // we had some exception handling for this
    // as the contract for these was between 2 independent applications
    // liable to change between versions (mostly adding new stuff)
    // but keeping it simple here.
    return null;
    }
}

使用ProtocolType.fromInt(2)从接收的值(例如1,2)创建enum对象 使用myEnumObj.name写入日志

希望这能有所帮助。