What is the initialization order of Java classes

Initialization sequence of Java classes

It’s useless to say more. The following is the code I personally tested, which is clear at a glance:

 1 package test1;
 2 
 3 public class Test {
 4     public static void main(String[] argc) {
 5         new Child();
 6         System.out.println("================================");
 7         new Child();
 8     }
 9 }
10 
11 class Child extends Parent{
12     private static String staticField = getStaticField();
13     static {
14         System.out.println("child静态方法块初始化");
15     }
16     private String field = getField();
17     {
18         System.out.println("child普通方法块初始化");
19     }
20 
21     public Child() {
22         System.out.println("child构造函数初始化");
23     }
24 
25     public static String getStaticField() {
26         System.out.println("child静态属性初始化");
27         return "staticField";
28     }
29 
30     public static String getField() {
31         System.out.println("child普通属性初始化");
32         return "field";
33     }
34 }
35 
36 class Parent {
37     private static String staticField = getStaticField();
38     static {
39         System.out.println("parent静态方法块初始化");
40     }
41     private String field = getField();
42     {
43         System.out.println("parent普通方法块初始化");
44     }
45 
46     public Parent() {
47         System.out.println("parent构造函数初始化");
48     }
49 
50     public static String getStaticField() {
51         System.out.println("parent静态属性初始化");
52         return "staticField";
53     }
54 
55     public static String getField() {
56         System.out.println("parent普通属性初始化");
57         return "field";
58     }
59 }

Print result:

 1 parent静态属性初始化
 2 parent静态方法块初始化
 3 child静态属性初始化
 4 child静态方法块初始化
 5 parent普通属性初始化
 6 parent普通方法块初始化
 7 parent构造函数初始化
 8 child普通属性初始化
 9 child普通方法块初始化
10 child构造函数初始化
11 ================================
12 parent普通属性初始化
13 parent普通方法块初始化
14 parent构造函数初始化
15 child普通属性初始化
16 child普通方法块初始化
17 child构造函数初始化

By replacing the declaration order of static attributes and static initialization blocks, it is found that the initialization order of static attributes and static initialization blocks is related to the declaration order. Similarly, the initialization order of ordinary attributes and ordinary initialization blocks is related to the declaration order.

Summarize:

1. When a class meets the conditions for initialization (there will be a summary in a future blog), the parent class will be initialized first (initializing from the top parent class Object downward), and then the subclasses will be initialized;

2. When initializing this class, static properties and static initialization blocks are initialized first (related to the declaration order), and initialized downwards from the top-level parent class Object;

3. When creating an object through new, first initialize the ordinary properties and ordinary initialization blocks (related to the declaration order), and then call the constructor method, also executing downwards from the top-level parent class Object;

4. Static properties and static initialization blocks will only be initialized once. After the class is initialized, creating an object through new again will only repeat the third step.

Next is a quote from Java programming ideas:

Within a class, the order of variable definitions determines the order of initialization. Even if variable definitions are scattered among method definitions, they will still be initialized before any method (including the constructor) is called.

The above is the detailed content of What is the initialization order of Java classes. For more information, please follow other related articles on the PHP Chinese website!