单例设计模式的一点心得

解决的问题：保证内存中只有一个对像（比如多个程序使用同一个配置信息）;

如 何 实现： 1、        不允许其它程序用new 创建该类对象

　　　　　　2、        在该类创建一个本类实例

　　　　　　3、        对外提值一个方法让其它程序获取该对象

 

步骤：        1、        私有化该类构造函数；

　　　　　　2、        通过new在本类中创建一个静态本类对象

　　　　　　3、        定义一个公有的、静态的方法，将创建的对象返回（一般为getInstance()）

饿汉式（开发时使用）：        一上来就初始化一个实例

懒汉式（面试）：                需要的时候再创建实例(延时加载)，但在多线程时无法证对象的唯一性

 1                 class Single{                                        //饿汉模式
 2                 
 3                     private Single(){}                               //这样就不能在外面New了
 4                 
 5                     private static Single s = new Single();          //饿汉就自己new一个吧
 6                 
 7                     public static Single getInstance(){              //静态方法返回自己生产的那个对象,不过不管调用只能返回同一个哦~~
 8                         return s;
 9                     }
10                     void print(){
11                         System.out.println("Hello World!");
12                     }
13                 }
14                 
15                 class Single2{                                                          
16                     private Single2(){}
17                 
18                     private static Single2 s2 = null;                //懒汉模式与饿汉模式的区别就在这,需要了我再去new
19                 
20                     public static Single2 getInstance(){  
21                         if(s2 == null){
22                             s2 = new Single2();
23                         }
24                         return s2;
25                     }
26                 }
27                 
28                 public class SingleDemo{
29                     public static void main(String[] args){
30                         Single s = Single.getInstance();
31                         s.print();
32                         //Single s = new Single();
33                         //System.out.println("Hello World!");
34                     }
35                 }