基于enum的单例

一个老问题的现代视角

这种方法通过利用Java的保证来实现单例，即任何enum值在Java程序中只实例化一次，并且enum为线程安全提供了隐式支持。由于Java枚举值是全局可访问的，因此它们可以作为单例使用。

public enum Singleton {
    SINGLETON; 
    public void method() { }
}

这是如何工作的呢?好吧，代码的第二行可以被认为是这样的:

public final static Singleton SINGLETON = new Singleton(); 

我们得到了早期初始化的单例。

记住，因为这是一个枚举，你总是可以通过Singleton访问实例。单例也是:

Singleton s = Singleton.SINGLETON;

优势

To prevent creating other instances of singleton during deserialization use enum based singleton because serialization of enum is taken care by JVM. Enum serialization and deserialization work differently than for normal java objects. The only thing that gets serialized is the name of the enum value. During the deserialization process, the enum valueOf method is used with the deserialized name to get the desired instance. Enum based singleton allows to protect itself from reflection attacks. The enum type actually extends the java Enum class. The reason that reflection cannot be used to instantiate objects of enum type is that the java specification disallows and that rule is coded in the implementation of the newInstance method of the Constructor class, which is usually used for creating objects via reflection:

if ((clazz.getModifiers() & Modifier.ENUM) != 0)
    throw new IllegalArgumentException("Cannot reflectively create enum objects");

Enum不应该被克隆，因为每个值必须只有一个实例。 所有单例实现中最简洁的代码。

缺点

The enum based singleton does not allow lazy initialization. If you changed your design and wanted to convert your singleton to multiton, enum would not allow this. The multiton pattern is used for the controlled creation of multiple instances, which it manages through the use of a map. Rather than having a single instance per application (e.g. the java.lang.Runtime) the multiton pattern instead ensures a single instance per key. Enum appears only in Java 5 so you can not use it in the prior version.

单例模式有几种实现方式，每一种都有优缺点。

急装单件 双重检查锁定单例 初始化-按需holder习语 基于enum的单例

详细的描述每个都太啰嗦了，所以我只是放了一个链接到一篇好文章-所有你想知道的关于Singleton

到目前为止，我从未需要使用枚举。自从它们在1.5或tiger版本中被引入以来，我就一直在阅读有关它们的文章。他们从未真正为我解决过一个“问题”。对于那些使用它的人(我看到他们中的很多人这样做)，我确信它肯定有某种目的。只有我的2英镑。

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

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

最简单的例子是一组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());
        }
    };
}

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

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

Enum表示枚举，即逐个提到(一些事情)。

enum是一种包含固定常数集的数据类型。

OR

枚举就像一个类，在编译时有一组固定的实例。

例如:

public class EnumExample {
    interface SeasonInt {
        String seasonDuration();
    }

    private enum Season implements SeasonInt {
        // except the enum constants remaining code looks same as class
        // enum constants are implicitly public static final we have used all caps to specify them like Constants in Java
        WINTER(88, "DEC - FEB"), SPRING(92, "MAR - JUN"), SUMMER(91, "JUN - AUG"), FALL(90, "SEP - NOV");

        private int days;
        private String months;

        Season(int days, String months) { // note: constructor is by default private 
            this.days = days;
            this.months = months;
        }

        @Override
        public String seasonDuration() {
            return this+" -> "+this.days + "days,   " + this.months+" months";
        }

    }
    public static void main(String[] args) {
        System.out.println(Season.SPRING.seasonDuration());
        for (Season season : Season.values()){
            System.out.println(season.seasonDuration());
        }

    }
}

枚举的优点:

Enum提高了编译时检查的类型安全性，以避免在运行时出现错误。 枚举可以很容易地用于交换机 枚举可以遍历 枚举可以有字段、构造函数和方法 enum可以实现许多接口，但不能扩展任何类，因为它在内部扩展了enum类

更多的

枚举?为什么要使用它?我认为当你使用它的时候会更容易理解。我也有同样的经历。

假设您有一个创建、删除、编辑和读取数据库操作。

现在如果你创建一个枚举作为一个操作:

public enum operation {
    create("1")
    delete("2")
    edit("3")
    read("4")

    // You may have is methods here
    public boolean isCreate() {
        return this.equals(create);
    }
    // More methods like the above can be written

}

现在，你可以这样声明:

private operation currentOperation;

// And assign the value for it 
currentOperation = operation.create

所以你可以在很多方面使用它。对于特定的事情使用enum总是好的，因为上面例子中的数据库操作可以通过检查currentOperation来控制。也许有人会说，这也可以用变量和整数值来实现。但我相信Enum更安全，更适合程序员。

另一件事:我认为每个程序员都喜欢布尔，不是吗?因为它只能存储两个值，两个特定的值。所以Enum可以被认为具有相同类型的功能，用户可以定义它将存储多少和什么类型的值，只是方式略有不同。：）

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

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

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

举个例子，哪个更好?

/** 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);

已经不可能了。