1. class A
   
2. {
   
3.    private static A a = new A();
   
4. 
   
5.    private B b = B.getInstance();
   
6. 
   
7.    private A(){}
   
8. 
   
9.   public static A getInstance()
   
10.   {
    
11.     System.out.println("A被调用");
    
12.     return a;
    
13.   }
    
14. 
    
15.   public void test()
    
16.   {
    
17.   System.out.println(b);
    
18.   }
    
19. }
    
20. 
    
21. 
    
22. class B
    
23. {
    
24.    private static B b = new B();
    
25. 
    
26.   private A a = A.getInstance();
    
27. 
    
28.   private B(){}
    
29. 
    
30.   public static B getInstance()
    
31. {
    
32.    System.out.println("B被调用");
    
33.    return b;
    
34. }
    
35. 
    
36.   public void test()
    
37.   {
    
38.     System.out.println(a);
    
39.   }
    
40. }
    
41. 
    
42. 
    
43. class Test
    
44. {
    
45.    public static void main(String[] args)
    
46.    {
    
47.      B b = B.getInstance();
    
48.      b.test();
    
49.      System.out.println("==========");
    
50.      A a = A.getInstance();
    
51.     a.test();
    
52.   }
    
53. }

复制代码

个人认为程序的运行结果是：
B被调用
A类的哈希值
=======
A被调用
B类的哈希值

但是程序运行结果是
B被调用
A被调用
B被调用
A@35ce36
==========
A被调用
null


不知道刚开始的两个输出语句怎么来的，还有最后一个null怎么来的，希望高手解答

这个程序运行过程是这样的，首先在主函数中按顺序得执行B类中的程序，所以首先是“B被调用”而后的return b；返回到了A类中b的实例对象（private B b = B.getInstance(); ），所以就开始执行A类中的程序，所以第二行打印的是“A被调用”，而后的return a;返回到B类中a的实例对象（private A a = A.getInstance();），所以就执行b类则第三行打印的是“B被调用”，接着就开始执行B类中test方法，所以就打印了a的哈希值，这个程序的方法就出栈了，B类里的内存就释放掉了，按主函数的顺序第五航就打印了“=====”紧接着就执行A类中方法，所以第六行打印的就是“A被调用，然后执行return a，在这里用说明一下因为刚才B类执行完内存就已释放掉了，所以里面方法就会空了，当它返回给B类中a的实例对象，因为里面为空所以最后打印结果就是null。

我把楼主的程序改动了一下，可是运行结果还是看不懂，希望楼上给解释一下
class A
{
        private static A a = new A();

        private B b = B.getInstance();

        private A()
        
        {
                System.out.println("A构造函数");
        }
        
        public static A getInstance()
        {
                System.out.println("A被调用");
                return a;
    }

}
class B
{
        private static B b = new B();
        
        private A a = A.getInstance();

        private B(){System.out.println("B构造函数"); }
        
        public static B getInstance()
        {
                System.out.println("B被调用");
                return b;
        }
}
class Test
{
        public static void main(String[] args)
        {
                B b = B.getInstance();
   
        }
}

关于第一个问题，你在类的构造函数前加了private私有化后是不能在被其他类new 对象的，而去掉private后可以编译通过，
但是运行后应该是内存出错，创建了A的对象，A又创建B的对象，都互相调用了，下面是打印的结果at B.<init>(Test.java:17)
                                                                                                                                                                                at A.<init>(Test.java:12)
                                                                                                                                                                                at B.<init>(Test.java:17)
                                                                                                                                                                                at A.<init>(Test.java:12)
                                                                                                                                                                                。。。。。。。。
至于第二个问题，可将主函数的内容一句一句的运行，看打印结果
class Test
{
        public static void main(String[] args)
        {
                B b = B.getInstance();
                //b.test();
                //System.out.println("==========");
                //A a = A.getInstance();
                //a.test();
        }
}
将后面几句话注释后结果为
B被调用
A被调用
B被调用
class Test
{
        public static void main(String[] args)
        {
                //B b = B.getInstance();
                //b.test();
                //System.out.println("==========");
                A a = A.getInstance();
                //a.test();
        }
}
将前面几句话注释掉后打印结果为
A被调用
B被调用
A被调用
由此可见运行B b = B.getInstance()与A a = A.getInstance() A类与B类都会双方调用一次分别产生a的对象与b对象，
当内存中有了a与b对象后就不会产生新的对象了，因为对象是唯一的，所以A a = A.getInstance()只调用了不会产生新的对象了，我花了不少时间还没完全搞懂，这个问题挺复杂的。

黑马-唐磊 发表于 2012-8-6 18:32
这个程序运行过程是这样的，首先在主函数中按顺序得执行B类中的程序，所以首先是“B被调用”而后的return b ...

为什么会将实例对象b返回到A类中去呢，而且还会执行A类中的程序，然后又从A类中返回a对象到B类中呢，这个过程到底是怎么执行的啊？