class Fu
{
        int num ;
        Fu()
        {
                num =10;
                System.out.println("A fu run");
        }
        Fu(int x)
        {
                System.out.println("B fu run..."+x);
        }
}
class Zi extends Fu
{
        int num;
        Zi()
        {
                //super();//调用的就是父类中的空参数的构造函数。
               
                System.out.println("C zi run"+num);
        }
        Zi(int x)
        {
                this();
                //super();
//                super(x);
                System.out.println("D zi run "+x);
        }
}

class  ExtendsDemo4
{
        public static void main(String[] args)
        {
                new Zi(6);
        }
}
class Demo//extends Object
{
        /*
        
        Demo()
        {
                super();
                return;
        }
        */
}


运行结果：
A fu run
C zi run0  //父类已经赋值了10啊   怎么变0了？？？？？？？
D zi run 6

为什么父类的num改变了，子类的num就必须改变呢。

因为你的子类里有 int num; 没这句就是10。
数据型实例变量默认初始化为0。

class Fu
{
        int num ;
        Fu()
        {
                num =10;
                System.out.println("A fu run");
        }
        Fu(int x)
        {
                System.out.println("B fu run..."+x);
        }
}
class Zi extends Fu
{
        //int num;   //没有输出10的原因就是因为你在这定义了num,把这注释了就会输出 C zi run 10
        Zi()
        {
                //super();//调用的就是父类中的空参数的构造函数。

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

class  ExtendsDemo4
{
        public static void main(String[] args)
        {
                new Zi(6);
        }
}

      public static void main(String[] args)
        {
                new Zi(6);
        }
  这一步，开始执行zi的带参数的那个构造函数。如下：
        Zi(int x)
        {
                this();
                //super();
//                super(x);
                System.out.println("D zi run "+x);
        }
  在这个构造函数中，先调用了this()，也就是zi类中的zi()构造函数，如下：、        Zi()
        {
                //super();//调用的就是父类中的空参数的构造函数。
               
                System.out.println("C zi run"+num);
        }

   但是，在调用这个构造函数的时候，必须先调用基类的构造函数，从而初始化基类。由于在这里没有显示的调用
基类的构造函数，所以默认调用的是基类无参数版本的那个构造函数（上面的那个super()注释）,而基类的
默认构造函数入下：      Fu()
        {
                num =10;
                System.out.println("A fu run");
        }
   所以毫无疑问，先输出“A fu run”。

执行完这个基类的默认构造函数，然后返回到派生类zi的默认构造函数中继续执行剩下的代码，如下：
        {
                //super();//调用的就是父类中的空参数的构造函数。
               
                System.out.println("C zi run"+num);
        }
  这时候开始执行System.out.println(“C zi run”+num) 在这个库num还没有被显示初始化为任何值，所以就初始化为默认值0
所以这里的输出为 C zi run 0.

this()调用的是：
Zi()
        {
                //super();//调用的就是父类中的空参数的构造函数。
               
                System.out.println("C zi run"+num);
        }
这个构造方法中是默认调用父类无参函数
num显示的是0 ，因为那是子类中的num，即System.out.println("C zi run"+num)的num，而父类中的num   System.out.println("A fu run")没有打印，可能你忘了 System.out.println("A fu run")添加“+num”这个啦，如果添加就会打印出 ：
A fu run 10
C zi run 0  
D zi run 6

*子类可以在自己的构造方法中使用super调用基类的构造方法
（使用this调用本类的另外的构造方法）
如果调用super，必须写在子类构造方法的第一位上
*如果子类没有显示调用基类的构造方法，系统默认使用基类的无参构造方法
*如果子类既无显示调用基类的构造方法，而系统又没有无参构造方法，那编译错误

因为你在子类又重新定义了一个num，而这个变量你没有进行赋值，输出语句默认调用这个变量，你可以在子类中去掉这个变量就能看到你要的结果了。
或者在子类输出语句中显式调用父类的num变量～方法是：super.num