java中单例设计模式中说是保证只生成一个对象共其他类或方法使用。
那其他类或方法使用一次岂不是生成一个新的对象啦吗？为什么说是唯一呢？？？？
很郁闷 啊....new 都在那写这呢，虽然不能写  CLassName cn=new CLassName ();
可是  别的方法使用一次   cn=new CLassName ();    这句过一次  ，  岂不是  用一次 创建一次咯？

卤煮 看这个饿汉式的例子

1. class Single
   
2. {
   
3. 
   
4. 
   
5.         private  Single(){}
   
6. 
   
7.         private static Single s = new Single();
   
8. 
   
9.         public static  Single getInstance()
   
10.         {
    
11.                 return s;
    
12.         }
    
13. }
    

复制代码

构造函数被私有化,所以其他类不能通过 new来获取single的对象,只能通过 getInstance方法.
而 private static Single s = new Single();是私有并且静态的
也就是说类加载s就加载 并且只加载一次.
这个对象是共享,内存中只有一份,不会被new多个.
你再看下懒汉式

1. class Single
   
2. {
   
3.         private static Single s = null;
   
4.         private Single(){}
   
5.         public static Single getInstance()
   
6.         {
   
7.                 if(s==null)
   
8.                 {
   
9.                         synchronized(Single.class)
   
10.                         {                               
    
11.                                 if(s==null)
    
12.                                         s = new Single();
    
13.                         }
    
14.                 }
    
15.                 return s;
    
16.         }
    
17. }

复制代码

s不存在则创建,存在则直接返回s.不会出现两个对象.

在楼上的例子中，其实你可以看到，这个对象是被私有的，得到这个对象（确切说是它的引用，楼上的为s变量），是通过getInstance()这个方法得到的，外界访问的时候并没有创建新对象，只是拿了s这个引用型变量使用的。
而且，你是不是也发现了，上面的例子中，那个s是被static修饰的，也就是说这个对象是在类加载的时候就已经跟着加载了。所以它是属于这个类的，也就是仅有一份。关于静态的知识你可以看看相关的资料和总结。

1. class Single
   
2. {
   
3.         private  Single(){}//将构造函数私有化
   
4. 
   
5.         private static Single s = new Single();//自己建立对象，注意static修饰符
   
6. 
   
7.         public static  Single getInstance()//返回新建对象引用的方法
   
8.         {
   
9.                 return s;
   
10.         }
    
11. }

复制代码

这是饿汉式。
当加载该类的时候，由于Single对象s是静态的，所以会被加载到方法区的静态区并被执行，因此该类一被加载，堆内存中就已经建立该对象。其它类在使用时调用方法getInstance()得到的只是该对象的引用。注意只是得到了该对象的地址，自始至终堆内存中只有一个对象。