java中构造函数-静态代码块-代码块的执行顺序

た入场券 2022-12-23 00:34 152阅读 0赞

面试题中，经常遇到这种题，我们只要记住一个原则，就不会出错。

三者的执行顺序：静态代码块>代码块>构造函数

package com.lbl.constructor;
    
    /** * Created by 李柏霖 * 2020/11/20 20:25 */
    
    public class Test01 { 
        public Test01() { 
            System.out.println("==== 父 ====");
        }
        public Test01(int b) { 
            System.out.println("==== 父 ===="+b);
        }
        static { 
            System.out.println("==== 父static ====");
        }
    
        { 
            System.out.println("=== 父代码块 ====");
        }
    }
    
    class Demo extends Test01 { 
        public Demo() { 
            super();
            System.out.println("==== 子 ====");
        }
        public Demo(int a) { 
            super(a);
            a=10;
            System.out.println("==== 子 ===="+a);
        }
        { 
            System.out.println("=== 子代码块 ====");
        }
        static { 
            System.out.println("==== 子static ====");
        }
    
        public static void main(String[] args) { 
            Demo demo1 = new Demo();
            Demo demo2 = new Demo(1);
        }
    }

执行的结果是什么？  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTI0OTA1_size_16_color_FFFFFF_t_70_pic_center]

为什么呢？

我们一步一步分解来看。

## 分解1-父子构造方法 ##

package com.lbl.constructor;
    
    /** * Created by 李柏霖 * 2020/11/20 20:25 */
    
    public class Test01 { 
        public Test01() { 
            System.out.println("==== 父 ====");
        }
    }
    
    class Demo extends Test01 { 
        public Demo() { 
            System.out.println("==== 子 ====");
        }
       
    
        public static void main(String[] args) { 
            Demo demo1 = new Demo();
        }
    }

这段代码的结果是什么呢？  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTI0OTA1_size_16_color_FFFFFF_t_70_pic_center 1]

因为在执行子类的构造方法前会先执行父类的构造方法。

总的来说一句话，每个子类的构造方法中（不管子类构造方法中是否带参数），都会有一个隐藏的super()方法，这个会调用父类的无参构造方法

## 分解2-static静态方法 ##

package com.lbl.constructor;
    
    /** * Created by 李柏霖 * 2020/11/20 20:25 */
    
    public class Test01 { 
        public Test01() { 
            System.out.println("==== 父 ====");
        }
        static { 
            System.out.println("==== 父static ====");
        }
    
    }
    
    class Demo extends Test01 { 
        public Demo() { 
            System.out.println("==== 子 ====");
        }
        static { 
            System.out.println("==== 子static ====");
        }
    
        public static void main(String[] args) { 
            Demo demo1 = new Demo();
        }
    }

这段代码的结果又是什么呢？

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTI0OTA1_size_16_color_FFFFFF_t_70_pic_center 2]

静态代码块>代码块>构造函数

答案一眼就知道了。会先执行静态方法，且会先执行父类的静态方法。

## 分解3-代码块 ##

package com.lbl.constructor;
    
    /** * Created by 李柏霖 * 2020/11/20 20:25 */
    
    public class Test01 { 
        public Test01() { 
            System.out.println("==== 父 ====");
        }
        static { 
            System.out.println("==== 父static ====");
        }
    
        { 
            System.out.println("=== 父代码块 ====");
        }
    }
    
    class Demo extends Test01 { 
        public Demo() { 
            System.out.println("==== 子 ====");
        }
        { 
            System.out.println("=== 子代码块 ====");
        }
        static { 
            System.out.println("==== 子static ====");
        }
    
        public static void main(String[] args) { 
            Demo demo1 = new Demo();
        }
    }

这段代码执行的结果是什么呢？  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTI0OTA1_size_16_color_FFFFFF_t_70_pic_center 3]

静态代码块>代码块>构造函数

先执静态代码块，且先执行父类的静态代码块，再执行子类的静态代码块。

再执行父类的代码块，父类的构造方法。

再执行子类的代码块。子类的构造方法。

## 分解4-带参的构造方法 ##

package com.lbl.constructor;
    
    /** * Created by 李柏霖 * 2020/11/20 20:25 */
    
    public class Test01 { 
        public Test01() { 
            System.out.println("==== 父 ====");
        }
        public Test01(int b) { 
            System.out.println("==== 父 ===="+b);
        }
    }
    
    class Demo extends Test01 { 
        public Demo() { 
            System.out.println("==== 子 ====");
        }
        public Demo(int a) { 
            a=10;
            System.out.println("==== 子 ===="+a);
        }
    
        public static void main(String[] args) { 
            Demo demo2 = new Demo(1);
        }
    }

这一套的执行结果是什么呢？

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTI0OTA1_size_16_color_FFFFFF_t_70_pic_center 4]

静态代码块>代码块>构造函数

因为`new Demo(1);`是带参数的,所以会调用子类带参数的构造函数。

但在子类带参数的构造函数中，会有一个隐藏的`super()`方法，调用父类无参的构造函数。

a的值按顺序，开始是1，后面a=10，改为了10。

## 最终 ##

package com.lbl.constructor;
    
    /** * Created by 李柏霖 * 2020/11/20 20:25 */
    
    public class Test01 { 
        public Test01() { 
            System.out.println("==== 父 ====");
        }
        public Test01(int b) { 
            System.out.println("==== 父 ===="+b);
        }
        static { 
            System.out.println("==== 父static ====");
        }
    
        { 
            System.out.println("=== 父代码块 ====");
        }
    }
    
    class Demo extends Test01 { 
        public Demo() { 
            System.out.println("==== 子 ====");
        }
        public Demo(int a) { 
            super(a);
            a=10;
            System.out.println("==== 子 ===="+a);
        }
        { 
            System.out.println("=== 子代码块 ====");
        }
        static { 
            System.out.println("==== 子static ====");
        }
    
        public static void main(String[] args) { 
            Demo demo1 = new Demo();
            Demo demo2 = new Demo(1);
        }
    }

最后我们来分析一下最终版：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTI0OTA1_size_16_color_FFFFFF_t_70_pic_center 5]

静态代码块>代码块>构造函数

`Demo demo1 = new Demo();`还是上面那一套不变

先执静态代码块，且先执行父类的静态代码块，再执行子类的静态代码块。

再执行父类的代码块，父类的构造方法。

再执行子类的代码块。子类的构造方法。

下面我们来分析：`Demo demo2 = new Demo(1);`

因为静态代码块只会执行一次，所以这次不会再执行

而是执行父类的代码块，父类的带参构造方法。

最后执行子类的代码块，子类的带参构造方法。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTI0OTA1_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/ed4897ce721847059dafed7d1da8fd21.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTI0OTA1_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/107b0a30b18941e3869b23feaf0f1994.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTI0OTA1_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221120/f9857ac3ce5347f4b5288573f44506ab.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTI0OTA1_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221120/c4d80e28f5f24698b96440c8011b43e8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTI0OTA1_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221120/e0d4611bcc1c4285803c58bea6f06bad.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTI0OTA1_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221120/4213e6e9699a40139288a9160d5574ee.png