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(有參) ，走父類的有參構造）

        子類非靜態 -- 子類構造 （創建子類對象時無參走無參構造，有參走有參構造）

 

 

如果還記不住，就想象一下下面的場景：

大家可以想象成父親教兒子打籃球，父子帶了一個 籃球，一開始坐在一邊看別人打籃球，父親和兒子都不動，是靜態的，后來父親教兒子運球，父親做完了之后指導兒子做，你想想籃球的動靜狀態和在誰的手中，

一開始父子都看別人打球，自己的籃球是靜態的，就是父靜態，子靜態。

后來父親完成運球動作，父非靜態，父類構造。

再后來兒子運球，子非靜態，子類構造。

 

方便自己記憶，不喜勿噴。