package com.duapp.itfanr;
class Atom {
    Atom() {

        System.out.println("A");
}

}



class Rock extends Atom {



    Rock() {



        System.out.println("B");

    }

}



class Moutain extends Rock {



    Moutain() {

    System.out.println("C");

    }



}



public class MainTest {



    public static void main(String[] args) {



        new Moutain();

    }

//为什么结果不是C????

构造函数默认第一句是 super();   调用的父类的构造函数

构造函数一般都会默认调用父类的无参构造函数，例子中super()被隐藏了！当父类无无参构造函数时，要手动调用父类的构造函数……

打印了一下结果是ABC。之前学C++的时候老师讲过子类父类构造函数，析构函数的调用方法。不过貌似java没有析构函数。实例化一个无参构造函数时，先看这个类有没有父类，有父类的话，就先调用父类的无参构造方法，再调用子类的。就相当于子类的构造函数前面加了一句“super();" 。本例中new Moutain();先调用Rock父类，而Rock父类的无参构造方法，前面也相当于加了一句“super();"，这时候Rock父类再调用它的父类的 Atom 的无参构造方法。所以结果是ABC  
另外我试验了一下有参构造函数，发现有参构造函数并不会默认加super(参数）的。下面是在你代码前提下加的的测试代码，注释和没加注释的结果是不一样的。

1. package com.study.two;
   
2. 
   
3. class Atom {
   
4.         String name="atom";
   
5.         Atom() {
   
6. 
   
7.                 System.out.println("A");
   
8.         }
   
9.         Atom(String name){
   
10.                 System.out.println("Atom::"+name);
    
11.         }
    
12. 
    
13. }
    
14. class Rock extends Atom {
    
15. 
    
16.         Rock() {
    
17. 
    
18.                 System.out.println("B");
    
19. 
    
20.         }
    
21.     Rock(String name){
    
22.             //super(name);
    
23.             System.out.println("Rock::"+name);
    
24.     }
    
25. }
    
26. class Moutain extends Rock {
    
27.         Moutain() {
    
28.         super();
    
29.                 System.out.println("C");
    
30. 
    
31.         }
    
32.         Moutain(String name){
    
33.         //        super(name);
    
34.                 System.out.println("Moutain::"+name);
    
35.         }
    
36. 
    
37. }
    
38. public class MainTest {
    
39. 
    
40.         public static void main(String[] args) {
    
41. 
    
42.                 new Moutain();
    
43.                 new Moutain("moutain");
    
44. 
    
45.         }
    
46. }
    

复制代码

事实证明：
    子类默认调用父类的无参构造方法；
    如果在代码中申明默认的无参构造函数，并有函数体，如在构造函数中打印语句，相当于覆写默认的构造函数
  package com.itheima;

public class test
{
        public static void main(String[] args)
        {
        new Moutain();
    }
}
class Atom
{
    Atom()
    {
        System.out.println("A");
   }

}

class Rock extends Atom
{
    Rock()
    {
        System.out.println("B");
    }
   
    //当去掉Rock()构造方法市，将不会打印B，子类调用默认的构造方法
    //而  System.out.println("B");相当于复写了默认的构造方法
}

class Moutain extends Rock
{
   public Moutain()
   {
          super();//去掉此句，结果一样，证明子类默认调用父类的无参构造方法
      System.out.println("C");

    }

}

子类对象在创建的时候会先调用自己的构造函数成员变量进行初始化,而子类的构造函数默认的第一行是super();就跑去调用父类的无参构造函数,所以结果是 ABC

很多人已经给了答案