Java子类继承父类，创建子类对象时的执行顺序

我们知道如何创建一个对象，但是却不清楚对象内部的执行顺序，一个例子，搞清楚，不要傻傻分不清楚。

首先我们需要一个父类

public class Father {
    
    static{
        System.out.println("父类的静态代码块{}执行了。。。");
        System.out.println();
    }
    
    {
        System.out.println("父类的非静态代码块{}执行了。。。");
        System.out.println();
    }
    
    public Father(){
        System.out.println("父类的无参构造structure 执行了。。。");
        System.out.println();
    }
    
    public Father(String name,Integer age){
        //super(); 默认执行父类的无参构造
        this.name = name;
        this.age = age;
        System.out.println("父类的有参构造structure 执行了。。。");
        System.out.println();
    }
    
    public static void Read(){
        System.out.println("父类的静态Read方法执行了。。。");
        System.out.println();
    }
    
    public void tour(){
        System.out.println("父类的非静态tour方法执行了。。。");
        System.out.println();
    }
    
    private String name;
    private Integer age;
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
    public Integer getAge() {
        return age;
    }
    
    public void setAge(Integer age) {
        this.age = age;
    }


}

 

其次再来一个子类

public class Son extends Father {

    static{
        System.out.println("子类的静态代码块{}执行了。。。");
        System.out.println();
    }
    
    {
        System.out.println("子类的非静态代码块{}执行了。。。");
        System.out.println();
    }
    
    public Son(){
        //super(); 默认执行Father的无参构造
        System.out.println("子类的无参构造structure 执行了。。。");
        System.out.println();
    }
    
    
    
    public Son(String name, Integer age) {
        //super(); 默认执行Father的无参构造
        super(name,age); //执行Father的有参构造
        this.name = name;
        this.age = age;
        System.out.println("子类的有参构造structure 执行了。。。");
        System.out.println();
    }

    public static void Read(){
        System.out.println("子类的静态Read方法执行了。。。");
        System.out.println();
    }
    
    @Override
    public void tour(){
        System.out.println("子类的非静态tour方法执行了。。。");
        System.out.println();
    }
    
    private String name;
    private Integer age;
    
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

}

 

接下来来一个测试类

public class MainTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        

        Son son = new Son();
        System.out.println("======================");
        Son son1 =new Son("谭谭",32);
        

    }

}

 

大家先来想想执行的结果，是一个什么顺序，想想小时候学习Java时老师是怎么讲的，不好意思，忘了，那废话不多说，直接来干货

 

 

 

 

 

 

 

干货来了

 

 

 

 

 

执行结果

父类的静态代码块{}执行了。。。

子类的静态代码块{}执行了。。。

父类的非静态代码块{}执行了。。。

父类的无参构造structure 执行了。。。

子类的非静态代码块{}执行了。。。

子类的无参构造structure 执行了。。。

====================== 父类的非静态代码块{}执行了。。。

父类的有参构造structure 执行了。。。

子类的非静态代码块{}执行了。。。

子类的有参构造structure 执行了。。。

 

啥？就这。。。 看的眼花，整不明白，谭谭来给你捋一下

就是先创建父类 -- 再子类，记住肯定是先把父类创建好，再创建子类，这是一个大顺序，

至于单个类中的执行顺序就需要大家花点脑子记一下，先静态-- 后非静态，ok,有了这个概念就不会搞错执行顺序了。

 

总结：

        父类静态 -- 子类静态（静态代码块只执行一次）

        父类非静态 -- 父类构造 （子类无参构造写不写super() ，默认都走父类无参构造。子类构造写super(有参) ，走父类的有参构造）

        子类非静态 -- 子类构造 （创建子类对象时无参走无参构造，有参走有参构造）

 

 

如果还记不住，就想象一下下面的场景：

大家可以想象成父亲教儿子打篮球，父子带了一个 篮球，一开始坐在一边看别人打篮球，父亲和儿子都不动，是静态的，后来父亲教儿子运球，父亲做完了之后指导儿子做，你想想篮球的动静状态和在谁的手中，

一开始父子都看别人打球，自己的篮球是静态的，就是父静态，子静态。

后来父亲完成运球动作，父非静态，父类构造。

再后来儿子运球，子非静态，子类构造。

 

方便自己记忆，不喜勿喷。