1 /*
  2 对于类中对成员变量的初始化和代码块中的代码全部都挪到了构造函数中，
  3 并且是按照java源文件的初始化顺序依次对成员变量进行初始化的，而原构造函数中的代码则移到了构造函数的最后执行
  4 */
  5 import static java.lang.System.out;
  6
  7 public class PersonDemo
  8 {
  9     public static void main(String[] args)
 10     {
 11          //*********测试父类与子类之间的循环调用的问题
 12         out.println("main1");
 13
 14         Father f = new Father();
 15
 16         out.println("main2");
 17
 18         f.show();
 19
 20         out.println("main3");
 21
 22         //*********测试两个无关类的循环调用的问题
 23
 24                 MyClass11 m1=new MyClass11();
 25             m1.myOut();
 26     }
 27 }
 28
 29 class Father
 30 {
 31     public Son s ; //=new Son();
 32
 33         /*
 34               public Song s= new Son(), 注意在这里进行初始化操作相当于在构造函数中进行初始化，会导致栈溢出， why？
 35               在主函数中我们产生了一个Father对象， 然后在new一个Son对象的过程中，Son对象调用其父类的构造方法来完成
 36               一些子类中包含父类成员的初始化，最终导致了循环调用，最终栈溢出
 37         */
 38     public newSon ns =null; // new newSon();
 39
 40     public Father()
 41     {
 42         this(10);
 43         System.out.println("Father");
 44     }
 45
 46     public Father(int a)
 47     {
 48         //this();很显然， 加上这一句就会形成构造函数递归调用！哈哈。。。
 49     }
 50
 51     public void show()
 52     {
 53         s = new Son();
 54                 /*
 55               如果我们将 s 的赋值操作放在这里， 也就是去掉 public Son s = new Son()的初始化，这样就不会导致栈溢出了
 56                     看一看也就会明白了， new Son（）时会调用父类Father的构造方法来完成Son的一些成员的初始化，但是其父类构造
 57                     函数中没有行循环调用！
 58                 */
 59         ns = new newSon();
 60
 61         System.out.println("father show");
 62
 63         s.show();
 64         ns.show();
 65     }
 66
 67     public class newSon extends Father//内部类同样会导致上面的问题！
 68     {
 69         public newSon()
 70         {
 71             System.out.println("newSon");
 72         }
 73
 74         public void show()
 75         {
 76             System.out.println("newSon show");
 77         }
 78     }
 79 }
 80
 81 class Son extends Father
 82 {
 83     public int a = 20;
 84
 85     public Son()
 86     {
 87         super();
 88         System.out.println("Son");
 89     }
 90
 91     public void show()
 92     {
 93         System.out.println("Son show");
 94     }
 95 }
 96
 97 class MyClass11{
 98
 99     MyClass22 m2;
100    //MyClass22 m2=new MyClass22();//这样写会导致循环调用问题
101
102    public MyClass11(){
103        //m2=new MyClass22();//这样写和上面的错误是一样的
104    }
105    public void show(){
106       System.out.println("This MyClass11");
107    }
108    public void myOut(){
109        m2=new MyClass22();//m2的赋值放在这里
110        m2.show();
111    }
112 }
113
114 class MyClass22{
115
116    MyClass11 m1;
117    public MyClass22(){
118        m1=new MyClass11();//移位main（）函数中没有定义MyClass22的对象，所以这句赋值不会导致循环调用的问题，只需要将MyClass11中的赋值操作更改一下就好了
119    }
120    public void show(){
121       System.out.println("This MyClass22");
122    }
123    public void myOut(){
124        m1.show();
125    }
126 }