class Demo
{
        Demo d = new Demo()
        Demo()
        {
                System.out.println("demo run");
        }
}

class DemoDemo
{
        public static void main(String[] args)
        {
                new Demo();
        }
}

程序运行的时候会产生一个栈溢出的异常，如下：
Exception in thread "main" java.lang.StackOverflowError
你在main()方法中创建一个Demo对象，而Demo对象在初始化成员变量的时候，又要去创建一个Demo对象，从而产生死循环，导致栈溢出。
联想到单例模式，可以发现，当成员变量是自身对象的时候，通常不初始化，只是一个定义，而在方法中对其进行赋值，这样就不会产生溢出了，具体如下：
class Demo
{
         Demo d;
         Demo()
         {
                 System.out.println("demo run");
         }
         public void setDemo() {
                 d = new Demo();
         }
}

你这个程序会报出这样的错误：
Exception in thread "main" java.lang.StackOverflowError的错误

意思就是
是栈溢出的错误。进入了死循环。是在程序里多写了Demo d =new Demo()，此处的Demo是没有被实际使用到的类。



请注意！当类DemoDemo中使用了Demo d = new Demo();的时候。因为在类Demo的方法外有个Demo d = new Demo();。所以出现了栈溢出。这样写是没有意义的，因为又不是单例模式，也不需要在本类中自己创建对象，况且即使是单例模式也不是这种写法

1. /**
   
2. * 能应对大多数情况的单例实现
   
3. */
   
4. public class SingletonKerrigan implements Serializable {
   
5. 
   
6. private static class SingletonHolder {
   
7. /**
   
8. * 单例对象实例
   
9. */
   
10. static final SingletonKerrigan INSTANCE = new SingletonKerrigan();
    
11. }
    
12. 
    
13. public static SingletonKerrigan getInstance() {
    
14. return SingletonHolder.INSTANCE;
    
15. }
    
16. 
    
17. /**
    
18. * private的构造函数用于避免外界直接使用new来实例化对象
    
19. */
    
20. private SingletonKerrigan() {
    
21. }
    
22. 
    
23. /**
    
24. * readResolve方法应对单例对象被序列化时候
    
25. */
    
26. private Object readResolve() {
    
27. return getInstance();
    
28. }
    
29. }
    

复制代码

可以顺便学学单例设计模式，以上是一种单例设计模式的写法。给予楼主参考。
毕老师讲了两种单例设计模式的实现方案。懒汉式和饿汉式。
Single类一进内存，就已经创建好了对象。

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

复制代码

当然懒汉式因为同步降低效率，建议使用饿汉式。饿汉式也有不能使用的情况，最上面的实现方式能适应大多数的场合。

这可以算是一个没有出口的递归调用，每次你new 一个Demo时就会调用 Demo d = new Demo()，从而再次new 一个Demo ；这养的话这个初始化会在栈内存中new无限次 。所以编译器回提醒你栈溢出。其实这个问题很好解决，只要把Demo d = new Demo()，改成 Demo d；就行了。