class Fu
{
        Fu()
        {
                System.out.println("fu run");
        }
}
class Zi extends Fu
{
        Zi()
        {
                System.out.println("zi run");
        }
        Zi(int x)
        {
                System.out.println("zi..."+x);
        }
}
class ExtendsStudy
{
        public static void main(String[] args)
        {
                Zi z = new Zi();
                Zi z1 = new Zi(3);
        }
}
//如何看这段继承中构造函数的运行情况，给注释一下，谢谢！

1. class Fu
   
2. {
   
3.         Fu()
   
4.         {
   
5.                 System.out.println("fu run");
   
6.         }
   
7. }
   
8. class Zi extends Fu
   
9. {
   
10.         Zi()
    
11.         {
    
12.                         //super();子类构造函数第一行中都有一个隐式的父类构造函数super()，这里的super()等同于Fu();
    
13.                                                 //所以在执行子类构造函数时都会执行父类的这个隐式构造函数
    
14.                 System.out.println("zi run");
    
15.         }
    
16.         Zi(int x)
    
17.         {
    
18.                         //super();//同上面
    
19.                 System.out.println("zi..."+x);
    
20.         }
    
21. }
    
22. class ExtendsStudy
    
23. {
    
24.         public static void main(String[] args)
    
25.         {
    
26.                 Zi z = new Zi();//执行过程Fu()-->Zi()
    
27.                 Zi z1 = new Zi(3);//执行过程Fu()-->Zi(int x)
    
28.         }
    
29. }
    
30. 
    

复制代码

打印结果：
fu run
zi run
fu run
zi...3

        从2楼的代码可以清楚的看出，子类对象在实例化前会默认调用父类中的构造函数。就好像没有父亲就没有孩

子，所以在实例化子类对象前需要先将父类中的属性进行初始化。当然，你的代码实际上在子类的构造方法中隐含了

一个super()的语法。                                         //你不加也没有关系。java自动帮你加。

一个有参的，一个无参的，具体他会调用看你传不传参数或传入什么类型的参数

其实这个代码里面用到了方法的重载，方法名相同，一个有参数，一个没有

1. 
   
2. class Fu
   
3. {
   
4.         Fu()//无参构造器
   
5.         {
   
6.                 System.out.println("fu run");
   
7.         }
   
8. }
   
9. class Zi extends Fu
   
10. {
    
11.         /*因为这个类Zi继承了Fu类，所以当new一个Zi类对象的时候，就会首先去调用父类中的默认构造方法（无参数构造器）
    
12.          * 如果父类中没有定义默认构造器的话，就需要在子类中显示调用父类中的其他有参构造器。
    
13.          * */
    
14.         Zi()
    
15.         {
    
16.                 //super();此处隐藏了super方法，隐式调用父类的无参数构造器
    
17.                 System.out.println("zi run");
    
18.         }
    
19.         Zi(int x)//它重载了默认的构造函数
    
20.         {
    
21.                 //super();此处也隐藏了super方法，隐式调用父类的无参数构造器
    
22.                 System.out.println("zi..."+x);
    
23.         }
    
24. }
    
25. class Z
    
26. {
    
27.         public static void main(String[] args)
    
28.         {
    
29.                 Zi z = new Zi();//会调用无参构造函数
    
30.                 Zi z1 = new Zi(3);//会调用有参构造函数
    
31.         }
    
32. }

复制代码

如果你还不明白的话，你可以设置断点，自己逐步调试一下，然后你就明白它的先后调用顺序了，加油