不管别人怎么说…在我曾经工作过的一个旧项目中，实体(独立应用程序)之间的大量通信使用代表一个小集合的整数。用静态方法将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写入日志

希望这能有所帮助。

从Java文档-

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

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

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

ENum代表“枚举类型”。它是一种具有一组固定常数的数据类型，由您自己定义。

Enum继承Object类和抽象类Enum的所有方法。所以你可以使用它的方法来反射、多线程、序列化、可比性等等。如果你只是声明一个静态常量而不是Enum，你就不能。除此之外，Enum的值也可以传递给DAO层。

下面是要演示的示例程序。

public enum State {

    Start("1"),
    Wait("1"),
    Notify("2"),
    NotifyAll("3"),
    Run("4"),
    SystemInatilize("5"),
    VendorInatilize("6"),
    test,
    FrameworkInatilize("7");

    public static State getState(String value) {
        return State.Wait;
    }

    private String value;
    State test;

    private State(String value) {
        this.value = value;
    }

    private State() {
    }

    public String getValue() {
        return value;
    }

    public void setCurrentState(State currentState) {
        test = currentState;
    }

    public boolean isNotify() {
        return this.equals(Notify);
    }
}

public class EnumTest {

    State test;

    public void setCurrentState(State currentState) {
        test = currentState;
    }

    public State getCurrentState() {
        return test;
    }

    public static void main(String[] args) {
        System.out.println(State.test);
        System.out.println(State.FrameworkInatilize);
        EnumTest test=new EnumTest();
        test.setCurrentState(State.Notify);
        test. stateSwitch();
    }

    public void stateSwitch() {
        switch (getCurrentState()) {
        case Notify:
            System.out.println("Notify");
            System.out.println(test.isNotify());
            break;
        default:
            break;
        }
    }
}

除了前面提到的用例，我经常发现枚举对于实现策略模式很有用，遵循一些基本的面向对象原则:

将代码放在数据所在的位置(即在枚举本身中——或者通常在枚举常量中，这可能会覆盖方法)。 实现一个(或更多)接口，以便不将客户端代码绑定到枚举(它应该只提供一组默认实现)。

最简单的例子是一组Comparator实现:

enum StringComparator implements Comparator<String> {
    NATURAL {
        @Override
        public int compare(String s1, String s2) {
            return s1.compareTo(s2);
        }
    },
    REVERSE {
        @Override
        public int compare(String s1, String s2) {
            return NATURAL.compare(s2, s1);
        }
    },
    LENGTH {
        @Override
        public int compare(String s1, String s2) {
            return new Integer(s1.length()).compareTo(s2.length());
        }
    };
}

这种“模式”可以在更复杂的场景中使用，广泛使用枚举附带的所有优点:遍历实例，依赖于它们的隐式顺序，根据实例名称检索实例，为特定上下文提供正确实例的静态方法等等。你仍然把这些都隐藏在接口后面，这样你的代码就可以在不需要修改的情况下使用自定义实现，以防你想要一些“默认选项”中不可用的东西。

我曾看到这种方法成功地应用于时间粒度(每天、每周等)概念的建模，其中所有逻辑都封装在枚举中(为给定的时间范围选择正确的粒度，将特定行为绑定到每个粒度作为常量方法等)。而且，服务层所看到的粒度只是一个接口。

枚举以自记录的方式枚举一组固定的值。 它们使您的代码更显式，也更不容易出错。

为什么不使用String，或int，而不是Enum常量?

编译器不允许错别字，也不允许出值的修正 设置，因为枚举本身就是类型。后果: 你不需要写一个先决条件(或手册)来确保你的论点在有效范围内。 类型不变式是免费的。 枚举可以有行为，就像任何其他类一样。 无论如何，您可能需要类似数量的内存来使用string(这取决于Enum的复杂性)。

此外，Enum的每个实例都是一个类，您可以为其定义单独的行为。

另外，它们在创建实例时(当枚举被加载时)确保线程安全，这在简化单例模式中有很好的应用。

这篇博客说明了它的一些应用，比如解析器的状态机。