JAVA中子类传参给父类构造函数完成初始化，所以先执行了子类的构造函数而后才执行了父类的构造函数？
class Bus extends Car
{
      Bus(String name)
      {
         super.name=name;
      }
}
但是实例化对象时，先有了子类还是先有了父类？

创建类时是先执行父类的构造函数的。可以看如下代码，当我们注释掉super("aa");这条语句时输出是in test1   in test2 当我们放开注释时输出是：in test1 string in test2
只是在执行父类的构造函数时会看子类构造函数来确定执行哪个父类构造函数，在子类中如果调用父类构造函数既super（）时必须放在第一句。实例化时是先有父类。
代码1：
class Test1{
        public Test1(){
                System.out.println("in test1");
        }
        public Test1(String mm){
                System.out.println("in test1 string");
        }
}
class Test2 extends Test1{
        public Test2(){
                //super("aa");
                System.out.println("in test2");
               
        }
}

/*
* 下面这段不考虑静态代码块或者静态成员变量！
*/
class Car extends Object{//object是一切类的上帝（父类）
        public String name = "张三";
        public Car(){
                //父类中的构造函数会对成员变量name进行显示的初始化，也就是”张三“的赋值动作是在构造函数中完成的
                //当父类中的构造函数执行完成后，在执行子类中的构造函数
        }
}
class Bus extends Car
{
      Bus(String name)
      {
             super();//在执行下面的代码的之前,先找到父类，去执行父类中的构造函数，如果没有super，JVM会自动为代码加上super
         super.name=name;
      }
}

实例化对象时应该先执行父类的构造方法，因为子类所有的构造函数，默认都会访问父类的空参构造函数，因为子类中每个构造函数内的第一行都有一句隐式super();
比如以下代码：

1. public class Car {
   
2.         public String name;
   
3.         public Car(){    //父类无参构造方法
   
4.                 System.out.println("父类构造方法！");
   
5.         }
   
6. }
   
7. public class Bus extends Car {
   
8.         public Bus(String name){   //子类构造方法
   
9.                 //super();   子类中每个构造函数内的第一行都有一句隐式'super();'
   
10.                 super.name = name;
    
11.                 System.out.println("子类构造方法！");
    
12.         }
    
13. }
    
14. public class FzTest {
    
15.         /**
    
16.          * @param args
    
17.          */
    
18.         public static void main(String[] args) {
    
19.                 // TODO Auto-generated method stub
    
20.                 Bus bus = new Bus("aa");  //创建子类实例对象
    
21.         }
    
22. }

复制代码

运行结果如下：

理解了，就是总之程序先进入子类构造函数，第一条就是执父类构造函数（隐式或者显式），而后才会执行子类构造函数中的剩余程序