public class FatherClass
{
public FatherClass()
{
System.out.println(“FatherClass Create”);
}
}
子类:
package test;
import test.FatherClass;
public class ChildClass extends FatherClass
{
public ChildClass()
{
System.out.println(“ChildClass Create”);
}
public static void main(String[] args)
{
FatherClass fc = new FatherClass();
ChildClass cc = new ChildClass();
}
}
结果是什么啊，请详细解释一下执行过程

大家想一下，这种方式 打印出来的又是什么呢？是不是会一直先调用父类的构造方法呢？

1. class GrandFather
   
2. {
   
3. 
   
4.         public GrandFather() {
   
5.                 System.out.println("Grandfather create");
   
6.         }
   
7.        
   
8. }
   
9. 
   
10. public class FatherClass extends GrandFather
    
11. {
    
12.         public FatherClass()
    
13.         {
    
14.         System.out.println("FatherClass Create");
    
15.         }
    
16. }
    
17. //子类:
    
18. 
    
19. class ChildClass extends FatherClass
    
20. {
    
21.         public ChildClass()
    
22.         {
    
23.          System.out.println("ChildClass Create");
    
24.         }
    
25.         public static void main(String[] args)
    
26.         {
    
27.         FatherClass fc = new FatherClass();
    
28.         ChildClass cc = new ChildClass();
    
29.         }
    
30. }

复制代码

继承时候类的执行顺序问题，构造函数初始化顺序。虽然听过，看过不少相关资料，但今天一开始还是没弄明白，只好拿到程序里面运行一下才确定：初始的时候先初始化继承的构造函数，再调用自己的构造函数。

下面是运行的程序

package test;

public class FatherClass {
    public FatherClass()
    {
     System.out.println("FatherClass Create");
    }
}
－－－－－－－－－－－－

package test;

public class ChildClass extends FatherClass {
public ChildClass()
{
   System.out.println("ChildClass Create");
}
public static void main(String[] args)
{
   FatherClass fc = new FatherClass();//这句输出FatherClass Create 就初始化调用构造函数
   ChildClass cc = new ChildClass();//这句输出FatherClass Create ChildClass Create
   //即初始的时候先初始化继承的构造函数，再调用自己的构造函数
}
}
－－－－－－－－－－－－－－－－－

输出结果：

FatherClass Create
FatherClass Create
ChildClass Create

－－－－－－－－－－－－－－－－－

研究方法：先注释掉ChildClass cc = new ChildClass();这句只输出FatherClass Create，说明创建子类对象的时候输出了两句，而且是先输出父类构造函数里面的再输出子类构造函数里面的，所以执行顺序是先父类后子类。

FatherClass Create
FatherClass Create
ChildClass Create
解释：声明父类对象的时候执行一次父类的构造方法；
      声明子类对象的时候先调用父类的构造方法然后再调用自己的构造方法。
所以会出现上面的情况。