1. class Single
   
2. {
   
3.     private Single(){}
   
4. 
   
5.         private static Singgle s = new single();  // 这里为什么没有造成死循环呢？
   
6. 
   
7.         public static Single singleGet()  
   
8.         {
   
9.                 return s；
   
10.         }
    
11. }
    
12. class SingleTest
    
13. {
    
14.         public static void main(String[] args)
    
15.         {
    
16.                 Single S = Single.singleGet();
    
17.         }
    
18. }
    

复制代码

唯一性的……怎么会死循环，而且你那个第二行调用对象时好像还写错了，多了一个g

Single  s = new Single();语句只执行一次，在类被加载时执行,在当执行到这句时在栈内存中会有一个s指向new single();  同时在堆内存中会开辟的空间。这里不是循环语句，所以就不用去想死循环的问题。

单例设计模式中，你所问的是饿汉式。当外部类需要本类的对象时，只能通过这个类名调用本类的singleGet()方法，此时虚拟机会将single类文件加到内存；然后创建一个对象。其实当程序运行一次，在内存的静态区只有一个single对象，当这个类被加载是就会new一个对象。
简单地说就是Single  s = new Single();这句话只执行一次，在类被加载时执行。他并不存在循环，所以更别说死循环

单例模式是为了保证对象的唯一性，不可能会有楼主说的死循环。

问题解决请联系我

是啊，单例模式的设计就是对象只创建一次，你还来死循环了，苍天啊大地啊，仔细看视频吧

1. [code]class Single
   
2. 
   
3. {
   
4. 
   
5.     private Single(){}
   
6. 
   
7. 
   
8.         private static Singgle s = new single();  // 2、当执行到这句时在栈内存中会有一个s指向new single();  在堆内存中开辟的空间。为什么你会想到循环呢？又不是循环语句
   
9. 
   
10. 
    
11.         public static Single singleGet()  
    
12. 
    
13.         {
    
14. 
    
15.                 return s；
    
16. 
    
17.         }
    
18. 
    
19. }
    
20. 
    
21. class SingleTest
    
22. 
    
23. {
    
24. 
    
25.         public static void main(String[] args)
    
26.         {
    
27. 
    
28.                 Single S = Single.singleGet(); //1、当调用了Single的.singleGet这个方法是Single这个类就被加载到内存
    
29.         }
    
30. 
    
31. }
    

复制代码

[/code]

1. public class Single {  
   
2.     //私有化构造函数   
   
3.     private Single(){}  
   
4.     //创建一个类的对象并使用private , static修饰；将对象私有化；   
   
5.     private static Single s=new Single();  
   
6.     //写一个方法向外提供一个对外使用对象的方法；   
   
7.     public static Single getInstance(){  
   
8.         return s;  
   
9.     }  
   
10. }  

复制代码

调用的都是一个对象在堆内存中只有一个指向，private static Singgle s = new single();   对象都指向了这个对象，这就是单利的特点啊。怎么会死循环呢