class Fu extends Object
{
        int num ;
        Fu()
        {
                super();
                System.out.println("fu run");
        }
        Fu(int x)
        {
                System.out.println("fu run "+x);
        }
}
class Zi extends Fu
{
        Zi()
        {
                super();

                System.out.println("zi run"+num);
        }
        Zi(int x)
        {
                this();
                System.out.println("zi run"+x);
        }
}

class ExtendsDemo4
{
        public static void main(String[] args)
        {
                new Zi(6);
        }
}
晕，对运行结果不太理解，
结果如下：
fu run
zi run0
zi run6
不明白为什么是这样？？
求指教。

这个题考察了继承，构造函数，重载。但执行主函数中的new Zi(6);的时候
调用  这个函数     Zi(int x)
                        {
                         this();
                           System.out.println("zi run"+x);
                         }    这个函数第一句代码的意思是调用本类的构造函数，
也就是    Zi()
        {
                super();

                System.out.println("zi run"+num);
        } 当调用这个函数时，第一行代码是 super();它要调用父类的构造函数

也就是   Fu()
        {
                super();
                System.out.println("fu run");
        }
所以做后的结果  就是   
fu run
zi run0
zi run6

class Fu extends Object
{
         int num ;
         Fu()
         {
                 super();
                 System.out.println("fu run");
         }
         Fu(int x)
         {
                 System.out.println("fu run "+x);
         }
}
class Zi extends Fu
{
         Zi()
         {
                 super();//继承了父类不带参数的构造方法

                System.out.println("zi run"+num);
         }
         Zi(int x)
         {
                 this();调用z()
                 System.out.println("zi run"+x);
         }
}

class ExtendsDemo4
{
         public static void main(String[] args)
        {
                 new Zi(6);
         }
}
所以
        Zi(int x)
         {
                 this();
                 System.out.println("zi run"+x);
         }
等价于
        Zi(int x)
         {
                                super();
                 System.out.println("fu run");
                System.out.println("zi run"+num);//num没有初始化所以默认为0
                 System.out.println("zi run"+x);
         }

这位同学的问题主要是关于构造子父类构造函数的执行情况。
程序首先执行主函数main中的new Zi(6);语句，该语句new一个带参数的子类对象，此时程序跳到子类中带参数的构造函数Zi(int x)，执行该构造函数时，先执行this();语句，即调用本类的空参数构造函数Zi()，接着执行空参数构造函数Zi()里面的super();语句，此时程序跳到父类的空参数构造函数Fu()，执行输出语句，打印fu run;
然后程序返回子类空参数构造函数Zi()，执行输出语句，打印zi run0（因为此时num还没初始化，故其值默认为0）；
接着程序返回到子类的带参数构造函数，执行该构造函数的输出语句，打印 zi run6。
程序的具体流程就是这样的。

1. class Fu extends Object
   
2. {
   
3.         int num ;
   
4.         Fu()
   
5.         {
   
6.                 super();
   
7.                 System.out.println("fu run");
   
8.         }
   
9.         Fu(int x)
   
10.         {
    
11.                 System.out.println("fu run "+x);
    
12.         }
    
13. }
    
14. class Zi extends Fu
    
15. {
    
16.         Zi()
    
17.         {
    
18.                 super();//调用构造函数Zi()时，首先调用父类中的构造函数
    
19. 
    
20.                 System.out.println("zi run"+num);
    
21.         }
    
22.         Zi(int x)
    
23.         {
    
24.                 this();//由于有this，则不会调用父类中的构造函数，而是调用本类中的无参数构造函数Zi()
    
25.                 System.out.println("zi run"+x);
    
26.         }
    
27. }
    
28. 
    
29. class ExtendsDemo4
    
30. {
    
31.         public static void main(String[] args)
    
32.         {
    
33.                 new Zi(6);//创建对象，调用构造函数Zi(int x)
    
34.         }
    
35. }

复制代码

1.创建对象时调用有参数的构造函数Zi(int x)，由于该构造函数中使用了this()语句，不会再调用父类的构造函数，而是调用本类中的无参数构造函数Zi()；
2.无参数构造函数中第一行是super()，则调用父类中的无参数构造函数，输出fu run；
3.父类构造函数调用完毕后，返回子类无参数构造函数继续执行后边的语句，由于在无参数构造函数中，num并未手动指定数值，所以默认初始化为0，输出zi run0；
4.子类无参数构造函数调用完毕以后，返回有参构造函数继续执行后边的语句，该构造函数中奖6传入x，故输出zi run6；
5.返回主函数，主函数结束。

所有的都在图里面，请看。