Java中构造方法、成员变量、代码块执行顺序

Posted on Symbols count in article: 2.1k Reading time ≈ 2 mins.

在网上看到有关Java中代码执行顺序的题目，第一次回答发现和答案不一致，于是想要亲自做个实验验证一下，解答心中的疑惑。

代码准备

  1. 创建父类Dog

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    public class Dog {
        
        private String name = getName();
        
        private static String gender = getGender();

        public String getName() {
            System.out.println("==>父类普通成员变量初始化");
            return "Dog";
        }
        
        public static String getGender() {
            System.out.println("==>父类静态成员变量初始化");
            return "male";
        }

        static {
            System.out.println("==>父类静态代码块1");
        }

        {
            System.out.println("==>父类普通代码块1");
        }
        
        public Dog() {
            System.out.println("==>父类构造方法");
        }

        static {
            System.out.println("==>父类静态代码块2");
        }

        {
            System.out.println("==>父类普通代码块2");
        }
        
    }

  2. 创建子类Husky

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    public class Husky extends Dog {
        
        private int age = getAge();
        
        private static String color = getColor();
        
        public int getAge() {
            System.out.println("==>子类普通成员变量初始化");
            return 2;
        } 
        
        public static String getColor() {
            System.out.println("==>子类静态成员变量初始化");
            return "BlackAndWhite";
        }
        
        static {
            System.out.println("==>子类静态代码块1");
        }

        {
            System.out.println("==>子类普通代码块1");
        }

        public Husky() {
            System.out.println("==>子类构造方法");
        }

        static {
            System.out.println("==>子类静态代码块2");
        }

        {
            System.out.println("==>子类普通代码块2");
        }
        
    }

  3. 创建测试主类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    public class TestRunOrder {

        public static void main(String[] args) {

            new Husky();
            System.out.println("");
            new Husky();
            
        }
        
    }

测试结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
==>父类静态成员变量初始化
==>父类静态代码块1
==>父类静态代码块2
==>子类静态成员变量初始化
==>子类静态代码块1
==>子类静态代码块2
==>父类普通成员变量初始化
==>父类普通代码块1
==>父类普通代码块2
==>父类构造方法
==>子类普通成员变量初始化
==>子类普通代码块1
==>子类普通代码块2
==>子类构造方法

==>父类普通成员变量初始化
==>父类普通代码块1
==>父类普通代码块2
==>父类构造方法
==>子类普通成员变量初始化
==>子类普通代码块1
==>子类普通代码块2
==>子类构造方法

结论

  • 父类静态成员变量/代码块>子类静态成员变量/代码块
  • 父类普通成员变量/代码块>子类普通成员变量/代码块
  • 父类构造方法>子类构造方法
  • 静态成员变量/代码块、普通成员变量/代码块执行顺序和代码位置一致