java中父類與子類， 不同的兩個類中的因為構造函數由于遞歸調用導致棧溢出問題...

/*
對于類中對成員變量的初始化和代碼塊中的代碼全部都挪到了構造函數中，
并且是按照java源文件的初始化順序依次對成員變量進行初始化的，而原構造函數中的代碼則移到了構造函數的最后執行
*/
import static java.lang.System.out;

public class PersonDemo
{
    public static void main(String[] args)
    {
         //*********測試父類與子類之間的循環調用的問題
        out.println("main1");

        Father f = new Father();
        
        out.println("main2");
        
        f.show();
        
        out.println("main3");

        //*********測試兩個無關類的循環調用的問題               
              
                MyClass11 m1=new MyClass11();
            m1.myOut();
    }
}

class Father
{
    public Son s ; //=new Son();
        
        /*
              public Song s= new Son(), 注意在這里進行初始化操作相當于在構造函數中進行初始化，會導致棧溢出， why？
              在主函數中我們產生了一個Father對象， 然后在new一個Son對象的過程中，Son對象調用其父類的構造方法來完成
              一些子類中包含父類成員的初始化，最終導致了循環調用，最終棧溢出
        */
    public newSon ns =null; // new newSon();
    
    public Father()
    {
        this(10);
        System.out.println("Father");
    }

    public Father(int a)
    {
        //this();很顯然， 加上這一句就會形成構造函數遞歸調用！哈哈。。。
    }
    
    public void show()
    {
        s = new Son();
                /*
              如果我們將 s 的賦值操作放在這里， 也就是去掉 public Son s = new Son()的初始化，這樣就不會導致棧溢出了
                    看一看也就會明白了， new Son（）時會調用父類Father的構造方法來完成Son的一些成員的初始化，但是其父類構造
                    函數中沒有行循環調用！
                */
        ns = new newSon();
        
        System.out.println("father show");

        s.show();
        ns.show();
    }
    
    public class newSon extends Father//內部類同樣會導致上面的問題！
    {
        public newSon()
        {
            System.out.println("newSon");
        }
        
        public void show()
        {
            System.out.println("newSon show");
        }
    }
}

class Son extends Father
{
    public int a = 20;
    
    public Son()
    {
        super();
        System.out.println("Son");
    }
    
    public void show()
    {
        System.out.println("Son show");
    }
}

class MyClass11{
  
    MyClass22 m2;
   //MyClass22 m2=new MyClass22();//這樣寫會導致循環調用問題
   
   public MyClass11(){
       //m2=new MyClass22();//這樣寫和上面的錯誤是一樣的
   }
   public void show(){
      System.out.println("This MyClass11");
   }
   public void myOut(){
       m2=new MyClass22();//m2的賦值放在這里
       m2.show();
   }
}

class MyClass22{
   
   MyClass11 m1;
   public MyClass22(){
       m1=new MyClass11();//移位main（）函數中沒有定義MyClass22的對象，所以這句賦值不會導致循環調用的問題，只需要將MyClass11中的賦值操作更改一下就好了
   }
   public void show(){
      System.out.println("This MyClass22");
   }
   public void myOut(){
       m1.show();
   }
}

?