深入探索Java单例模式：枚举实现的优势及应用

最新推荐文章于 2025-04-01 23:43:56 发布
最新推荐文章于 2025-04-01 23:43:56 发布
阅读量1.7k 收藏 16
点赞数 25
文章标签： 单例模式 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2301_78976656/article/details/141687834
版权

1. 引言

在项目开发的过程中单例的使用是很频繁和常见的。需要针对不同的场景使用不同的方式创建不同的单例。

在面向对象编程中，单例模式的使用广泛而重要。Java开发者经常利用单例模式来控制资源的访问，例如配置管理器、连接池或日志记录器。尽管有多种实现单例模式的方法，但枚举类型提供了一种易于实现且无缝提供线程安全的方法。

2. 单例模式传统实现

在深入枚举单例之前，先回顾传统的单例实现方法，如懒汉式、饿汉式、双重检查锁定等。并给出对应实现过程。

1. 饿汉式（Eager Initialization）

在类加载时就完成了初始化，所以类加载较慢，但获取对象的速度快。这种方法线程安全。

 

java
 

代码解读
 

复制代码
 

package com.dereksmart.crawling.single; /** * @Author derek_smart * @Date 2024/8/29 8:18 * @Description 饿汉式 */ public class Singleton { private static final Singleton INSTANCE = new Singleton(); private Singleton() {} public static Singleton getInstance() { return INSTANCE; } } 
 

 

2. 懒汉式（Lazy Initialization）
 

延迟类实例的初始化，即第一次调用 getInstance() 方法时才创建实例。这种方法在多线程环境下必须小心处理。
 

 

java
 

代码解读
 

复制代码
 

package com.dereksmart.crawling.single; /** * @Author derek_smart * @Date 2024/8/29 8:18 * @Description 懒汉式 */ public class Singleton1 { private static Singleton1 instance; private Singleton1() {} public static synchronized Singleton1 getInstance() { if (instance == null) { instance = new Singleton1(); } return instance; } } 
 

 

为了提高性能，可以使用双重检查锁定（Double-Checked Locking）：
 

 

java
 

代码解读
 

复制代码
 

package com.dereksmart.crawling.single; /** * @Author derek_smart * @Date 2024/8/29 8:18 * @Description 双重检查锁定 */ public class Singleton11 { private static volatile Singleton11 instance; private Singleton11() {} public static Singleton11 getInstance() { if (instance == null) { synchronized (Singleton11.class) { if (instance == null) { instance = new Singleton11(); } } } return instance; } } 
 

 

3. 静态内部类（Static Inner Class）
 

使用静态内部类来实现单例，这种方式既能确保延迟加载，又能保证线程安全。
 

 

java
 

代码解读
 

复制代码
 

package com.dereksmart.crawling.single; /** * @Author derek_smart * @Date 2024/8/29 8:18 * @Description 静态内部类 */ public class Singleton2 { private Singleton2() {} private static class SingletonHolder { private static final Singleton2 INSTANCE = new Singleton2(); } public static Singleton2 getInstance() { return SingletonHolder.INSTANCE; } } 
 

 

4. 枚举（Enum）
 

使用枚举实现单例是最简单的方法，这种方式是线程安全的，并且在任何情况下都是单例。
 

 
 
整理了一份好像面试笔记包括了：Java面试、Spring、JVM、MyBatis、Redis、MySQL、并发编程、微服务、Linux、Springboot、SpringCloud、MQ、Kafka 面试专题
 
 
需要全套面试笔记【点击此处即可】免费获取
 

 

java
 

代码解读
 

复制代码
 

package com.dereksmart.crawling.single; /** * @Author derek_smart * @Date 2024/8/29 8:18 * @Description 枚举 */ public enum Singleton3 { INSTANCE; public void someMethod() { // Some method } } 
 

 

这边简单写，后续详细论述
 

5. 使用 AtomicReference
 

AtomicReference 可以用来实现无锁的线程安全单例。
 

 

java
 

代码解读
 

复制代码
 

package com.dereksmart.crawling.single; import java.util.concurrent.atomic.AtomicReference; /** * @Author derek_smart * @Date 2024/8/29 8:18 * @Description AtomicReference */ public class Singleton4 { private static final AtomicReference<Singleton4> INSTANCE = new AtomicReference<>(); private Singleton4() {} public static final Singleton4 getInstance() { for (;;) { Singleton4 current = INSTANCE.get(); if (current != null) { return current; } current = new Singleton4(); if (INSTANCE.compareAndSet(null, current)) { return current; } } } } 
 

 

6. 使用 CAS 操作
 

通过 Unsafe 类和 CAS 操作也可以实现无锁的线程安全单例。
 

 

java
 

代码解读
 

复制代码
 

package com.dereksmart.crawling.single; import sun.misc.Unsafe; /** * @Author derek_smart * @Date 2024/8/29 8:18 * @Description `CAS` 操作 */ public class Singleton5 { private static final Unsafe unsafe = Unsafe.getUnsafe(); private static final long valueOffset; private static volatile Singleton5 instance; static { try { valueOffset = unsafe.objectFieldOffset(Singleton.class.getDeclaredField("instance")); } catch (Exception ex) { throw new Error(ex); } } private Singleton5() {} public static Singleton5 getInstance() { while (true) { Singleton5 current = instance; if (current != null) { return current; } current = new Singleton5(); if (unsafe.compareAndSwapObject(Singleton5.class, valueOffset, null, current)) { return current; } } } } 
 

 

注意：Unsafe 类的使用通常不推荐，因为它是非标准的 API，而且在未来版本的 Java 中可能会被移除或更改。
 

3. 枚举单例模式的优势
 

枚举单例模式是实现单例设计模式的一种方式，它在 Java 枚举类型的基础上提供了一种简洁、安全且易于使用的单例实现。下面是枚举单例模式的一些主要优势：
 

1. 简洁的语法
 

枚举单例模式的代码非常简洁。你只需要声明一个枚举类型并指定一个名称，JVM 就会保证这个枚举值是唯一的实例。不需要显式地编写用于创建和管理单例的代码。
 

2. 线程安全
 

在枚举单例模式中，实例的创建是由 JVM 在加载枚举类时完成的，这个过程是自然的线程安全的。因此，枚举单例不需要额外的同步机制来防止多线程下的多重实例化问题。
 

3. 防止反射攻击
 

传统的单例模式，如果不小心实现，可能会通过反射来创建新的实例。但枚举类型不允许通过反射来创建枚举常量，因为 Java 的 java.lang.reflect.Constructor 类中有一个显式的检查，如果构造器的目标是一个枚举类型，就抛出 IllegalArgumentException 异常。
 

4. 防止序列化问题
 

序列化和反序列化通常会破坏单例的原则，因为每次反序列化时都会创建一个新的实例。但是，枚举单例模式自动支持序列化机制，并且通过 JVM 的保证，每个枚举值在序列化和反序列化过程中保持单例。
 

5. 自动支持克隆保护
 

克隆（通过 clone() 方法）也能破坏单例的原则，但由于枚举类型不支持 clone() 方法（Enum 类没有实现 Cloneable 接口），所以枚举单例不会有克隆破坏单例的问题。
 

6. 枚举类易于维护
 

由于枚举类的定义非常集中和标准化，它们通常更易于维护和理解。单例的实现和使用都非常明确，没有隐藏的陷阱。
 

7. 枚举类的功能性
 

枚举类不仅可以包含数据字段，还可以包含自己的方法和构造器。这使得枚举单例可以像其他任何类一样拥有自己的状态和行为，同时保持单例的属性。
 

8. 无假性继承问题
 

在使用类来实现单例时，有时候会面临无法阻止继承的问题，其他类可以继承单例类从而破坏单例原则。枚举类型不允许被继承，这自然地防止了这个问题。
 

9. 性能优势
 

由于枚举单例不需要复杂的同步或者延迟加载机制，它通常能够在性能上有所优势，特别是在高并发场景下。
 

枚举单例模式的这些优势使其成为实现单例设计模式的最佳选择之一，尤其是在需要确保实例唯一性和防止多线程问题的场景中。然而，枚举单例模式也有其局限性，例如无法继承其他类，这在某些特定情况下可能会限制其使用。
 

4. 枚举单例的工作原理
 

枚举单例模式在 Java 中的工作原理基于 Java 枚举类型（enum）的语言特性。枚举类型是一种特殊的类类型，它提供了一组固定的常量实例。在枚举单例模式中，一个枚举类型定义了一个元素，这个元素在整个应用程序中是唯一的。以下是枚举单例模式工作原理的详细论述：
 

1. 枚举类型的定义
 

Java 中的枚举类型使用关键字 enum 定义，它隐式地继承自 java.lang.Enum 类。当我们定义一个枚举时，每个枚举常量都是一个公共的、静态的、最终的实例，而且是枚举类型的单一实例。
 

2. 类加载机制
 

当首次引用枚举类时，Java 类加载器会加载该枚举类。在加载过程中，每个枚举常量都会被实例化。类加载器在加载枚举类时提供了线程安全性，确保每个枚举常量只被实例化一次。
 

3. 枚举常量的实例化
 

枚举常量的实例化是在类加载时由 JVM 在静态初始化阶段完成的。这个过程不需要开发者编写任何特殊的代码，只需要声明枚举常量即可。由于这个实例化过程只发生一次，并且在类加载时完成，因此保证了单例的唯一性和线程安全性。
 

4. 防止反射创建新实例
 

Java 的枚举类型不允许通过反射来创建枚举常量。java.lang.reflect.Constructor 类中有一个显式的检查来防止这种情况。尝试通过反射创建枚举实例会抛出 IllegalArgumentException 异常。这防止了通过反射破坏单例的可能性。
 

5. 序列化机制
 

枚举类型的序列化和反序列化机制也与普通类不同。枚举的序列化只涉及枚举常量的名称；反序列化时，Java 会确保使用 Enum.valueOf() 方法来获取枚举常量的唯一实例，而不是创建一个新实例。这样，单例状态在序列化过程中得到保持。
 

6. 枚举方法和构造函数
 

虽然枚举类型不能被继承，但它们可以有自己的方法和构造函数。构造函数总是私有的，这意味着不能从枚举类型之外实例化枚举常量。这保证了枚举常量的唯一性。
 

示例：枚举单例模式的实现
 

 

java
 

代码解读
 

复制代码
 

public enum Singleton { INSTANCE; // 唯一的枚举实例，代表单例 // 在这里添加单例的属性和方法 private int value; public int getValue() { return value; } public void setValue(int value) { this.value = value; } } // 使用单例 public class SingletonDemo { public static void main(String[] args) { Singleton singleton = Singleton.INSTANCE; singleton.setValue(1); System.out.println(singleton.getValue()); // 输出 1 } } 
 

在上述示例中，Singleton 枚举定义了一个名为 INSTANCE 的枚举常量，这是单例的唯一实例。我们可以向枚举类型添加方法和属性，就像向普通类添加一样。当我们在 SingletonDemo 类中访问 Singleton.INSTANCE 时，我们实际上是在访问由 JVM 在类加载期间创建的唯一实例。
 

总结来说，枚举单例模式的工作原理是基于 Java 枚举类型的特性，结合了类加载机制和特殊的序列化处理，提供了一种简单、安全且高效的单例实现方式。
 

5. 枚举单例的扩展性和局限性
 

枚举单例模式是一种在 Java 中实现单例设计模式的有效方法，但就像所有设计模式一样，它也有其特定的使用场景、优点和局限性。以下详细论述了枚举单例的扩展性和局限性。
 

扩展性
 

  1.  
    添加方法和属性： 枚举单例可以像其他任何 Java 类一样添加方法和属性。这意味着你可以很容易地向单例添加更多的业务逻辑和数据存储功能。
     
  2.  
    实现接口： 尽管枚举不能继承其他类（因为它们已经继承了 java.lang.Enum），但它们可以实现接口。这允许你定义一些通用的操作，并通过枚举单例来实现这些操作。
     
  3.  
    使用策略模式： 由于枚举可以实现接口，你可以将策略模式与枚举单例相结合，枚举常量可以代表不同的策略实现。
     
  4.  
    单例的状态管理： 枚举单例可以持有状态，并提供线程安全的方法来管理这些状态。这使得它们非常适合于作为全局状态管理器。
     
 

代码示例
 

在Java中，策略模式是一种行为设计模式，它允许在运行时选择算法的行为。 当你使用枚举单例实现策略模式时，你可以定义一个接口来代表策略，并让不同的枚举实例代表不同的策略实现。 以下是一个使用枚举单例实现策略模式的示例代码：首先，我们定义一个策略接口：
 

 

java
 

代码解读
 

复制代码
 

public interface PaymentStrategy { void pay(int amount); } 
 

然后，我们创建一个枚举类，每个枚举常量都实现了这个接口：
 

 

java
 

代码解读
 

复制代码
 

public enum PaymentMethod implements PaymentStrategy { CREDIT_CARD { @Override public void pay(int amount) { System.out.println("Paid " + amount + " using Credit Card."); // 实现信用卡支付的逻辑 } }, PAYPAL { @Override public void pay(int amount) { System.out.println("Paid " + amount + " using PayPal."); // 实现PayPal支付的逻辑 } }, BITCOIN { @Override public void pay(int amount) { System.out.println("Paid " + amount + " using Bitcoin."); // 实现比特币支付的逻辑 } }; // 可以添加更多的方法和属性 } 
 

在这个例子中，定义了三种支付策略：信用卡、PayPal 和比特币。每种支付方式都有自己的支付逻辑。
 

现在，可以创建一个上下文类，它将使用这些策略：
 

 

java
 

代码解读
 

复制代码
 

public class PaymentContext { private PaymentStrategy paymentStrategy; public PaymentContext(PaymentStrategy paymentStrategy) { this.paymentStrategy = paymentStrategy; } public void executePayment(int amount) { paymentStrategy.pay(amount); } } 
 

最后，可以在客户端代码中使用这些策略：
 

 

java
 

代码解读
 

复制代码
 

public class StrategyDemo { public static void main(String[] args) { PaymentContext context = new PaymentContext(PaymentMethod.CREDIT_CARD); context.executePayment(1000); context = new PaymentContext(PaymentMethod.PAYPAL); context.executePayment(2000); context = new PaymentContext(PaymentMethod.BITCOIN); context.executePayment(3000); } } 
 

在这个例子中，StrategyDemo 类创建了一个 PaymentContext，并使用不同的支付方法来执行支付。当调用 executePayment 方法时，它将使用当前策略支付指定的金额。
 

这种方式的好处是，可以在不改变客户端代码的情况下添加新的支付策略。由于每个枚举实例都是单例，还可以在枚举类中添加状态和同步代码，以处理多线程环境下的支付。
 

以上示例展示了如何使用枚举单例实现策略模式，允许在运行时选择不同的算法实现，同时保持了简洁和线程安全。
 

局限性
 

  1.  
    不支持懒加载： 枚举单例在类加载时就被实例化，这意味着它们不支持懒加载。如果单例的初始化包含重量级的资源分配或配置加载，那么在不需要这些资源时提前加载可能会导致性能问题。
     
  2.  
    不支持继承： 枚举类型不能继承其他类，因为它们已经继承了 Enum 类。这限制了单例的扩展性，因为不能利用继承来重用或修改类的行为。
     
  3.  
    复杂性和灵活性有限： 对于复杂的单例实现，可能需要更多的灵活性，比如能够使用依赖注入、控制实例化时机或者进行单元测试。枚举单例由于其简单性，在这些方面可能会受到限制。
     
  4.  
    序列化控制有限： 虽然枚举单例提供了防止反序列化问题的保证，但如果需要对单例的序列化过程进行更细粒度的控制，枚举可能不是最佳选择。
     
  5.  
    内存占用： 由于枚举单例在类加载时就被创建，即使应用程序的当前状态不需要该单例，它仍然会占用内存，这可能导致资源的浪费。
     
  6.  
    反射限制： 一些高级的反射技术可能在枚举类型上不适用，因为枚举的构造函数是私有的，且反射创建枚举实例会抛出异常。
     
  7.  
    枚举常量的数量： 如果单例需要在运行时动态地增加实例，那么枚举单例就不适合，因为枚举常量的数量在编译时就已固定。
     
 

在使用枚举单例模式时，应该根据具体的应用场景和需求来权衡其优点和局限性。如果应用程序需要一个简单、线程安全的全局单例，并且不需要复杂的初始化或继承结构，那么枚举单例可能是一个很好的选择。如果需要更多的灵活性或者懒加载特性，那么可能需要考虑其他单例实现方法。
 

6. 结论
 

枚举单例模式是实现单例设计模式的一个极佳选择，特别是在需要明确的实例控制、线程安全和防止多种攻击的场景中。它简化了单例的实现，减少了出错的可能性，并且提供了一定程度的功能性。
 

然而，在选择使用枚举单例时，应该考虑到其局限性，并根据具体的应用场景和需求来决定是否适合使用。在需要更大的灵活性或特定的延迟加载行为时，可能需要考虑其他单例实现策略。

                

        

    

  



    



                



	

		

			

				
					
深入探索Java设计模式：工厂模式与单例模式的完美实现

				
			

			

				

					墨夶的博客
				

				

					01-07
					
					316
					
				

			

		

		

			
				
通过本文的介绍，我们不仅了解了工厂模式和单例模式的概念，还学习了如何在Java中实现这两种重要的设计模式。希望这些知识能够帮助您更好地理解面向对象编程的原则，并为您的开发工作带来新的启示。如果您对设计模式感兴趣，不妨继续深入研究其他模式，如策略模式、观察者模式等，让您的代码更加优雅、灵活和强大。

			
		

	



                

            
              



	

		

			

				
					
Java笔记——实现单例模式的七种写法

				
			

			

				

					a25847a的博客
				

				

					11-25
					
					2437
					
				

			

		

		

			
				
双重检查锁模式是一种非常好的单例实现模式，解决了单例、性能、线程安全问题，上面的双重检 测锁模式看上去完美无缺，其实是存在问题，在多线程的情况下，可能会出现空指针问题，出现问 题的原因是JVM在实例化对象的时候会进行优化和指令重排序操作。枚举类实现单例模式是极力推荐的单例实现模式，因为枚举类型是线程安全的，并且只会装载一 次，设计者充分的利用了枚举的这个特性来实现单例模式，枚举的写法非常简单，而且枚举类型是 所用单例实现中唯一一种不会被破坏的单例实现模式。instance对象是随着类的加载而创建的。

			
		

	



              


  
              

                


	

		

			

				
					
Java 枚举实现单例模式，线程安全又优雅！

				
			

			

				

					m0_71777195的博客
				

				

					03-17
					
					5259
					
				

			

		

		

			
				
枚举在序列化和反序列化时，并不会调用构造方法，这就防止了反序列化导致的单例破坏的问题。反编译任何一个枚举类会发现，枚举类里的各个枚举项是是通过static代码块来定义和初始化的(可以见后面3.2节反编译分析单例枚举有分析到这个)，它们会在类被加载时完成初始化，而java类的加载由JVM保证线程安全，所以，创建一个Enum类型的枚举是线程安全的。因为存在着指令重排序的优化，第2、3步的顺序是不能保证的，最后的执行顺序可能是1-2-3，也可能是1-3-2，假如执行顺序是1-3-2，我们看看会出现什么问题。

			
		

	





	

		

			

				
					
Java枚举实现单例模式

					
最新发布

				
			

			

				

					海星的博客
				

				

					04-01
					
					755
					
				

			

		

		

			
				
单例模式实现方式有很多种，常见的就不说了。今天主要记录一下用枚举的方式实现单例，Effffective Java 作者推荐使⽤枚举的⽅式解决单例模式，此种⽅式可能是平时最少⽤到的。之前也研究过怎么写，最近在开源项目hutool中看到有大神这么用的才彻底明白。
使用hutool编写单元测试类

输出结果

hutool工具包中枚举单例的使用用例

使用方式在CglibUtil类中
总结
可见枚举实现的单例模式也是懒汉式，这种方式在jvm层面无偿的提供了串行化的机制，但此种方式在存在集成的场景下是不可用的。

			
		

	



		

			
		



	

		

			

				
					
Java枚举enum以及应用：枚举实现单例模式

				
			

			

				

					weixin_30415113的博客
				

				

					03-21
					
					170
					
				

			

		

		

			
				
枚举作为一个常规的语言概念，一直到Java5才诞生不得不说有点奇怪，以至于到现在为止很多程序员仍然更喜欢用static final的形式去命名常量而不使用，一般情况下，Java程序员用这种方式去实现枚举：

class EnumByClass{
    public static final int RED=0;
    public static final int GREEN=1;
...

			
		

	





	

		

			

				
					
java枚举实现单例模式_枚举实现单例模式

				
			

			

				

					weixin_39814960的博客
				

				

					02-19
					
					165
					
				

			

		

		

			
				
package com.wz.thread.enums;import java.sql.Connection;import java.sql.DriverManager;/*** 使用枚举实现单例模式* @author Administrator**/public class MyObject {public enum MyEnumSingletion{connectionFactory;priv...

			
		

	





	

		

			

				
					
Java 利用枚举实现单例模式

				
			

			

				

					陈守璐的专栏
				

				

					11-02
					
					477
					
				

			

		

		

			
				
引言

单例模式比较常见的实现方法有懒汉模式，DCL模式公有静态成员等，从Java 1.5版本起，单元素枚举实现单例模式成为最佳的方法。


Java枚举

基本用法

枚举的用法比较多，本文主要旨在介绍利用枚举实现单例模式的原理，所以这里也主要介绍一些相关的基础内容。 
首先，枚举类似类，一个枚举可以拥有成员变量，成员方法，构造方法。先来看枚举最基本的用法：
enum Ty

			
		

	





	

		

			

				
					
Java枚举深入探索：单例、责任链与扩展功能

				
			

			

				

					
				

			

		

		

			
				
"Java枚举在程序设计中的应用和扩展，包括枚举的基本概念、功能、静态导入，以及如何向枚举中添加新方法、覆盖toString()方法和实现接口。"  在Java编程语言中，枚举（enum）是一种特殊的类，用于定义一组固定的常量...

			
		

	





	

		

			

				
					
单例模式的多种实现：Java单例模式的深入探讨与实践指南

				
			

			

				

					
				

			

		

		

			
				
[单例模式的多种实现：Java单例模式的深入探讨与实践指南](https://www.xudongvp.com/wp-content/uploads/2021/10/image-1024x431.png)  # 摘要 单例模式作为软件设计中的一种常用模式，确保了一个类只有一个实例，...

			
		

	





	

		

			

				
					
【Java枚举与单例模式】：探索枚举在设计模式中的完美融合

				
			

			

				

					
				

			

		

		

			
				
Java枚举与单例模式是两个不同的概念，但它们在软件开发中扮演着重要的角色。枚举，作为一种特殊的类，允许我们定义一组命名的常量。这些常量可以表示一组固定的数据集，如季节、星期等，它们具有类型安全和增强的...

			
		

	





	

		

			

				
					
JAVA 枚举单例模式及源码分析的实例详解

				
			

			

				

					08-29
				

			

		

		

			
				
主要介绍了 JAVA 枚举单例模式及源码分析的实例详解的相关资料,需要的朋友可以参考下

			
		

	





	

		

			

				
					
Java枚举深入探索：结合设计模式实例解析

				
			

			

				

					
				

			

		

		

			
				
"这篇资源主要讨论了Java中的枚举（enum）特性和如何结合设计模式来增强代码的性能和可读性。文章通过一个简单的枚举示例...本文深入探讨了Java枚举的使用技巧和它在设计模式中的应用，有助于提升代码的结构和效率。

			
		

	





	

		

			

				
					
Java设计模式之单例模式--枚举方式

				
			

			

				

					Miraitowup的博客
				

				

					05-13
					
					258
					
				

			

		

		

			
				
枚举方式的单例模式的代码实现及代码注释详细介绍
package 单例模式;

public class 枚举方式 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//检验
		singleen en1=singleen.instance ;
		singleen en2=singleen.instance ;
		System.out.println(en1==en2);
	}

}
//

			
		

	





	

		

			

				
					
全网最简单的Java设计模式【七】枚举实现单例设计模式

				
			

			

				

					技术管理修行
				

				

					07-16
					
					985
					
				

			

		

		

			
				
枚举实现单例模式的原理基于枚举的特性：每个枚举项都是 public static final 的，因此枚举天然就是单例的。枚举类型在Java中是一种特殊的类，它们不能被继承，也不能有显式的构造函数。这些特性使得枚举成为实现单例模式的理想选择。

			
		

	





	

		

			

				
					
java 枚举单例模式_枚举实现单例模式

				
			

			

				

					weixin_35982453的博客
				

				

					02-15
					
					365
					
				

			

		

		

			
				
1.引言单元素的枚举类型已经成为实现Singleton的最佳方法-- 出自 《effective java》2.单例模式的特点单例模式三个主要特点：1、构造方法私有化；2、实例化的变量引用私有化；3、获取实例的方法共有。3. 常用的单例模式1.单例的饿汉模式1   public class Singleton {2     /*3      * 利用静态变量来记录Singleton的唯一实例4  ...

			
		

	





	

		

			

				
					
浅谈JAVA使用枚举实现单例模式

				
			

			

				

					qq_30699731的博客
				

				

					08-11
					
					1221
					
				

			

		

		

			
				
在我们的日常开发中，会非常频繁的使用到一个模式-单例模式。

			
		

	





	

		

			

				
					
java最理想的单例模式-枚举

				
			

			

				

					MpenggegeM的博客
				

				

					03-11
					
					3230
					
				

			

		

		

			
				
饿汉式
public final class SingleEhan {
	
	private static final SingleEhan singleEhan = new SingleEhan();
	
	private SingleEhan() {
		
	}
	
	public static SingleEhan getSingleEhan() {
		return singleEhan;
	}
}

懒汉式
public final class SingleLanHan {
	private st

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值