单例模式 顾名思义 要保证内存中只有一个对象，我们操作的对象就是这一个。
请问，什么情况下使用单例模式呢？  请举例说明，尽量详细。

当你不想别的程序对你的类随意的建立对象的时候，也就是不能随意的new对象，因为new一个就是新建的一个对象。

什么叫单例

　　一个类只有一个实例对象，叫单例模式！

如何让外界无法创建对象，并且类内部自己可以创建

给本类写一个private构造器。（只给类留一个构造器，并且这个构造器是private）

    在本类内部自己创建一个本类的唯一对象。

什么叫饿汉式

l  只留一个 private构造器

l  写一个private static 本类类型的属性，并且显示初始化。

l  写一个public static返回值类型为本类类型的方法，内部return上面定义的属性。

public class Single {         private static Single instance = new Single();          public static Single getInstance() {                   return instance;         }         private Single() {         }}

什么叫懒汉式

public class Single {         private static Single instance;          public static Single getInstance() {                   if(instance == null) {                            instance = new Single();                   }                   return instance;         }         private Single() {         }}

单例从代码的格式上就能看出来很多的为什么
如果要求一个类的实例对象只有一个 这就需要用到单例了
国家主席类 只有一个实例  因为主席就有一个 所以在定力国家主席这个类的时候就要限定 只能有一个实体对象
比如人类  因为有很多人 所以实现这个类可以产生无数个实体对象  如果使用了单例 那么人类就只有一个实体对象 一个类了
希望我的解释对你有所帮助

  单例模式确保一个类只有一个实例，自行提供这个实例并向整个系统提供这个实例。
特点：      
1，一个类只能有一个实例   
2，自己创建这个实例     
3，整个系统都要使用这个实例

解决一个类在内存只存在一个对象。
想要保证对象唯一
1，避免其他程序过多建立对象，就禁止其他程序建立对象。
2，在本类中自定义一个对象，让其他程序可以访问到该类对象。
3，对外提供访问方式，方便其他程序对自定义对象的访问。
实现过程
1，构造函数私有化，禁止建立
2，建立对象，
3，提供方法，方便使用

需要保证唯一时，加上以上3步。其他一样。

懒汉式：方法被调用，才初始化，也叫对象的延时加载。
懒汉式容易出现安全隐患，需要加锁。建议使用饿汉式。
饿汉式：一进内存，已经初始化，建立好了对象。

1. class Single
   
2. {
   
3.         //饿汉式：一进内存，已经初始化，建立好了对象。
   
4.         //构造函数私有化，不能外部建立对象
   
5.         private Single(){}
   
6.         //自己建立对象，不能建立对象，只能类名调用，定义成静态
   
7.         private static Single s = new Single();
   
8.         //提供静态方法
   
9.         public static Silgle getInstance()
   
10.         {
    
11.                 return s;
    
12.         }
    
13. }
    
14. {
    
15.         //懒汉式：方法被调用，才初始化，也叫对象的延时加载。
    
16.         //建立时值为空，被调用时才加载       
    
17.         private static Single s = null;
    
18.         private Single(){}
    
19.         public static Silgle getInstance()
    
20.         {       
    
21.                 if(s==null)
    
22.                 {
    
23.                         //由于可能出现安全隐患，加锁进行双重判断
    
24.                         synchronized(Single.class)//静态锁是该类所属的字节码文件对象。
    
25.                         {
    
26.                                 if(s==null)
    
27.                                         s = new Single();
    
28.                         }
    
29.                 }
    
30.                 return s;
    
31.         }
    
32. }

复制代码

就是对象只要一个或者是你不想让别人建立对象时使用单例

比如软件的的配置文件，只能有一个吧，并且第一次运行时就建立，，这就是要保证对象的唯一性。

过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，
也就是给使用这个类的用户提供了一个静态的工厂方法
从而方便对实例个数的控制并节约系统资源。

主要的目的是节约系统资源。
比方说在windows下的任务管理器，它就是一个单例的最好体现。

如果你显示多个任务管理器，如果他们内容不一致，那就不对了，因为它们实时对应的是系统的属性，如果不一致，那么哪个才是真实的系统呢？。
如果它们显示的一致，那不就是浪费资源吗，为什么相同的对象要多次创建呢？
所以使用单例很好的解决了这个问题