函数运行的结果是：
A、子类无参构造函数 子类有参构造函数  父类无参构造函数
B、子类有参构造函数 子类无参构造函数  父类无参构造函数
C、父类无参构造函数 子类有参构造函数  子类无参构造函数
D、父类有参构造函数 子类有参构造函数  子类无参构造函数

1. public class Test
   
2. {
   
3.         public static void main(String [] args)
   
4. {        
   
5. Child c = new Child();
   
6. }
   
7. }
   
8. class Father
   
9. {
   
10.         public Father()
    
11. {
    
12.                 System.out.println("父类无参构造函数");
    
13.         }
    
14.         public Father(String name)
    
15. {
    
16.                 System.out.println("父类有参构造函数");
    
17. }
    
18. }
    
19. class Child extends Father
    
20. {
    
21. public Child()
    
22. {
    
23. this("dd");
    
24.                 System.out.println("子类无参构造函数");
    
25. }
    
26. public Child(String name){
    
27. super("dd");
    
28.                 System.out.println("子类有参构造函数");        
    
29. }
    
30. }

复制代码

Child c = new Child();函数走向
首先执行子类中的无参构造函数。

• public Child()
• {
• this("dd");//调用本类的有参函数
•                 System.out.println("子类无参构造函数");
• }
  

就是

• public Child(String name){
• super("dd"); //调用父类中的有参函数 ，System.out.println("父类有参构造函数");
•                System.out.println("子类有参构造函数");
• }
  

回到子类无参函数
System.out.println("子类无参构造函数");

D、父类有参构造函数 子类有参构造函数  子类无参构造函数
详解：
Child c = new Child();
1.首先执行子类中的无参构造函数。
2.运行this("dd");调用子类本类有参的函数。
3.运行super("dd");调用父类有参构造函数。
4.执行System.out.println("父类有参构造函数");
5.回到子类有参构造函数执行System.out.println("子类有参构造函数");
6.回到子类无参构造函数执行System.out.println("子类无参构造函数");

希望与楼主共同探讨{:soso_e100:}

答案应该是d ；
因为你定义的 是Child c = new Child();  
所以调用的 是child里面的空参数构造函数，在空参数构造函数里面第一句就是this("dd");这里访问子类的Child(String name)构造函数，
然后我们调用Child(dd)进去之后发现他第一句是super("dd");这里访问的是父类的  public Father(String name)构造函数，
然后我们调用Father("dd"),执行system.out.println("父类有参构造函数");之后在会过来执行Child(dd)里的 System.out.println("子类有参构造函数");      
最后在执行 System.out.println("子类无参构造函数");
话说楼主就贴了个代码，也不知道你哪里有问题。。

D、父类有参构造函数 子类有参构造函数  子类无参构造函数
注解：
1：但在主函数中执行Child c = new Child();时，就创建一个对象，这时就调用了子类Child的无参构造函数Child（）。
2：当在无参构造函数Child（）中执行this("dd")时;就调用了子类有参构造函数Child(String name）。this（“dd”）这叫构造函数之间的平行调用。
3：在有参构造函数Child(String name）中执行super("dd");时，就调用了父类的有参构造函数public Father(String name)。其实在默认的情况下，
    子类构造函数的第一行都用super（)语句，默认先调用父类中的无参构造函数。
所以答案是D。

上面讲得很明白了，我就补充一点
构造函数中，子类隐式的super()函数和this()构造函数平行调用不能同时出现，这是java的一个运行机制，简单点说就是this（）平行调用要求放在第一行，super（）隐式函数也是要求放在第一行，这样两个函数会打架的，哈哈，所以有了this（）后，隐式的super（）就不会出现了~~~

1. <p>public Child()
   
2. 
   
3. {
   
4.               //super();有了this()了，super()就没了
   
5.               this("dd");
   
6.               System.out.println("子类无参构造函数");
   
7. 
   
8. }
   
9. 
   
10. public Child(String name)</p><p>{
    
11.                 super("dd");
    
12.                 System.out.println("子类有参构造函数");        
    
13. }
    
14. </p>

复制代码