为什么枚举实现单例模式是安全的

老皇甫

于 2024-09-09 16:56:51 发布

阅读量733

点赞数 22

分类专栏： javaSE阶段文章标签： java

本文链接：https://blog.csdn.net/m0_73233932/article/details/141967949

版权

javaSE阶段专栏收录该内容

21 篇文章 0 订阅

订阅专栏

（一）枚举类

（1）什么是枚举类

枚举类就是用来定义一组常量，比如一年四季，一星期七天

（2）定义一个枚举类

public enum TestEnum {
    RED, BLACK, GREEN, WHITE;


}

枚举类的另一种定义方法

注意：1、当枚举对象有参数后，需要提供相应的构造函数
2、枚举的构造函数默认是私有的这个一定要记住

public enum TestEnum {
    RED("red",1),BLACK("black",2),WHITE("white",3),GREEN("green",4);
    private  String name;
    private  int key;
 
   
    private TestEnum (String name,int key) {// 构造函数
        this.name = name;
        this.key = key;
    }

    public static TestEnum getEnumKey (int key) {//根据key获取枚举
        for (TestEnum t: TestEnum.values()) {
            if(t.key == key) {
                return t;
            }
        }
        return null;
    }
    public static void main(String[] args) {
        System.out.println(getEnumKey(2));
       
    }
}

（3）枚举类常用方法

方法名	作用
values()	返回一个有所有枚举成员的数组
ordinal（）	获取枚举成员的索引
valueOf()	将字符串转化为枚举实例
compareTo（）	比较枚举成员定义前后顺序

简单使用方法

class Main {
    public static void main(String[] args) {
       // 枚举的values()方法
       TestEnum[] values = TestEnum.values();
        for (TestEnum x:
             values) {
            System.out.println(x);
        }
        //获取枚举成员的索引位置，枚举的ordinal()方法
        TestEnum enumRed = TestEnum.RED;
        System.out.println(enumRed.ordinal());
        //枚举的valueOf()方法
        TestEnum enumBlack = TestEnum.valueOf("BLACK");
        System.out.println(enumBlack);
        //比较枚举成员
        System.out.println(TestEnum.RED.compareTo(TestEnum.BLACK));
    }



}

（二）单例模式

（1）什么是单例模式

单例模式是一种软件设计模式，目的是为了确保一个类只有一个实例

(2)实现一个单例模式

2.1双重检验锁的单例模式

下列代码实现了一个，双重校验锁的单例模式，通过调用getSingleton()方法来创建实例，保证一个类只有一个实例

public class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {//通过调用此方法创建实例，保证只有一个实例被创建  
    if (singleton == null) {//提前判断singleton是否等于null,绕过synchronized提升性能安全  
        synchronized (Singleton.class) {  
            if (singleton == null) {  
                singleton = new Singleton();  
            }  
        }  
    }  
    return singleton;  
    }  
}

2.2枚举类实现的单例模式

枚举类


public enum SingletonEnum {
    INSTANCE; // 枚举元素本身就是单例对象的实例

    // 添加单例类需要的方法
    public void someMethod() {
        System.out.println("这是一个单例方法");
    }

    //添加一个静态方法，允许外部代码获取单例的实例（尽管在这个例子中，直接通过SingletonEnum.INSTANCE访问即可）
    public static SingletonEnum getInstance() {
        return INSTANCE;
    }

    // 示例：添加单例类可能需要的字段和方法
    private String someField = "这是一个单例字段";

    public String getSomeField() {
        return someField;
    }

    public void setSomeField(String someField) {
        this.someField = someField;
    }
}

使用示例

// 使用示例
public class SingletonEnumDemo {
    public static void main(String[] args) {
        SingletonEnum instance1 = SingletonEnum.getInstance();
        SingletonEnum instance2 = SingletonEnum.getInstance();

        // 验证是否为同一个实例
        System.out.println(instance1 == instance2); // 输出 true

        // 访问和修改单例字段
        System.out.println(instance1.getSomeField()); // 输出 这是一个单例字段
        instance1.setSomeField("修改后的单例字段");
        System.out.println(instance2.getSomeField()); // 输出 修改后的单例字段，因为instance1和instance2是同一个实例
    }
}

（三）枚举类实现的单例模式为什么是安全的

（1）可防止反射攻击

public enum TestEnum {
    RED("red",1),BLACK("black",2),WHITE("white",3),GREEN("green",4);
    private  String name;
    private  int key;

    /**
     * 1、当枚举对象有参数后，需要提供相应的构造函数
     * 2、枚举的构造函数默认是私有的 这个一定要记住
     * @param name
     * @param key
     */
    private TestEnum (String name,int key) {// 构造函数
        this.name = name;
        this.key = key;
    }

    public static TestEnum getEnumKey (int key) {//根据key获取枚举
        for (TestEnum t: TestEnum.values()) {
            if(t.key == key) {
                return t;
            }
        }
        return null;
    }
    public static void main(String[] args) {
        System.out.println(getEnumKey(2));

    }
}
class Main{
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
//通过反射创建实例
        Class<?> enumClass = TestEnum.class;
      Constructor enumConstructor = enumClass.getDeclaredConstructor(String.class,int.class,String.class,int.class);
      enumConstructor.setAccessible(true);

     Object obj =   enumConstructor.newInstance("hf",2);
    TestEnum testEnum = (TestEnum) obj;

    }
}

上面代码是一段尝试通过反射获取构造器来创建实例的代码

注意：在获取构造器时添加了四个参数的原因是，因为枚举类默认继承了java.lang.Enum，所以子类要帮助父类进行构造，但枚举类比较特殊，虽然我们在构造函数中只添加了两个参数，但默认地Enum类还添加了两个参数，源码如下

运行结果：

可以看到抛出了 Cannot reflectively create enum objects（无法反射式创建枚举对象），为什么会如此呢，我们来看Constructor源码

红框中的代码翻译过来就是，如果反射创建的实例是枚举类，则直接抛出异常，也就是说，如果反射创建的是枚举类，在源码中是会直接被过滤的

（2）枚举类的实例化

由于枚举类的实例化是由JVM保证的，并且是在类加载到JVM时进行的。由于JVM的类加载过程是线程安全的，因此枚举的实例化过程也是线程安全的。

（3）枚举类支持自动序列化

由于枚举类型的所有实例在JVM中都是唯一的，并且由枚举定义时明确列出，因此不需要在序列化过程中创建新的实例。当枚举实例被序列化时，Java序列化机制并不是通过保存对象的状态来序列化枚举实例，而是仅仅保存枚举的常量名称，当反序列化时，Java的序列化机制会读取枚举的常量名称，并通过Enum.valueOf()方法查找并返回对应的枚举实例。由于枚举的实例在JVM中是唯一的，因此反序列化时返回的是已经存在的实例，而不是创建一个新的实例。