单例模式都是将构造函数私有化，只对外提供一个获取对象的方法。private起到禁止其它程序创建该对象的作用。static修饰的最先加载，先初始化。

1. 单例模式用于保证在程序的运行期间某个类有且仅有一个实例。
   
2. 饿汉式：
   
3. class  SingleClass{
   
4.        
   
5.          //将构造函数私有化，不允许在类的外部创建该类的实例
   
6.         private SingleClass(){}
   
7.         /*创建该类的实例，并将其私有化，
   
8.         *该实例 需要在方法调用，因此也必须是静态的
   
9.         *对象一创建，就进行初始化，这种叫做饿汉式
   
10. */
    
11.         private static SingleClass singleInstance = new SingleClass();
    
12.         /*对外提供方法来获取该类的实例,该方法必须通过public修饰
    
13.         *该方法只能被类名调用，因此，方法必须是静态的
    
14.         *调用该方法是为了获取该类的实例，因此，该方法的返回值类型是该类类型*/
    
15.         public static SingleClass getInstance(){
    
16.                 return singleInstance;
    
17.         }
    
18. }
    
19.        
    
20. 懒汉式
    
21.        
    
22. class  SingleClass{
    
23. 
    
24.         private SingleClass(){}
    
25.        
    
26.         private static SingleClass  singleInstance  =null;
    
27.        
    
28.         public static SingleClass getInstance(){
    
29.        
    
30.                 /*如果对象为null，才创建*/
    
31.                 if (singleInstance == null)
    
32.                         singleInstance = new SingleClass();
    
33.                
    
34.                 return singleInstance;
    
35. 
    
36.         }
    
37. }
    
38. 
    
39. 
    
40. 懒汉式的线程安全问题
    
41. public static SingleClass getInstance(){
    
42. //这里会牵涉到线程安全问题，在保证同步的情况下注重效率
    
43.                 //在此处判断一次，若已经创建实例，就不在判断锁，稍微提高效率
    
44.                 if(singleInstance ==null) {
    
45.                         //此处加锁，保证只有一个线程创建实例
    
46.                         synchronized(SingleClass.class){
    
47.                                 if (singleInstance == null)
    
48.                                         singleInstance = new SingleClass();
    
49.                         }
    
50.                 }
    
51.                 return singleInstance;
    
52. }
    

复制代码

单例设计模式 就是保证该类在程序中只能存在一个对象，所以不能让别人实例化该类，所以要私有化（private）该类的构造函数，但是你要为别人提供一个该类的唯一对象，所以你要在该类中定义一个静态的方法返回本类对象。

饿汉呢就好比一个人非常饿迫不及待的上来就在本类中new了一个对象并返回，懒汉正好想反，什么时候饿了（在被调用时）才创建该对象并返回，也就是延迟加载。
    这是我对单例的理解希望对你有用

不要急不要急，稍微往后面学一点再看这一点就懂了。

static修饰的在类加载时初始化，只初始化一次

懒汉式是因为刚开始的时候需要判断才会去建立这个对象，所以有点慢，至于加私有呢，那是因为要控制其他的类建立这个类的对象，所以需要私有化这个类的构造函数

我晕，这次刚开始嘛！这么快就否定自己了？

记不住  就拼命记住为止！