Java类初始化顺序

一个类中包含如下几类东西，他们前后是有顺序关系的

1. 静态属性
2. 静态方法块
3. 普通属性
4. 普通方法块
5. 构造函数

先说结论：静态属性,静态方法块(并列优先级，按照代码中出现的先后顺序执行)>普通属性,普通方法块()>构造方法

话不多说，接下来上测试代码

 1 package src;
 2 
 3 import java.text.SimpleDateFormat;
 4 import java.util.Date;
 5 import java.util.regex.Matcher;
 6 import java.util.regex.Pattern;
 7 
 8 public class Child{
 9 
10     //普通属性
11     private int i = 1;
12 
13     //非静态代码块
14     {
15         System.out.println("这是非静态代码块：" + (i == 1));
16     }
17 
18     //静态属性
19     private static int j = 1;
20 
21     //静态方法
22     static {
23         System.out.println("这是一个静态方法：" + (j == 1));
24     }
25 
26     //构造体
27     public Child(){
28         System.out.println("这是构造体：");
29     }
30 
31     public static void main(String[] args){
32         new Child();
33     }
34 }

接下来看运行结果图

由两个true可以看出变量i与静态变量j均已经在方法前被赋值，由此可以推断出静态属性>静态方法块>普通属性>普通方法块>构造方法

2：当类有继承关系时

先说结论：单类中加载顺序不变，而同一类成员，先加载父类再加载子类

话不多说，接下来上测试代码

这是父类代码

 1 package src;
 2 
 3 public class Father {
 4 
 5     //普通属性
 6     private int i = 1;
 7 
 8     //非静态代码块
 9     {
10         System.out.println("父类非静态代码块：" + (i == 1));
11     }
12 
13     //静态属性
14     private static int j = 1;
15 
16     //静态方法
17     static {
18         System.out.println("父类静态方法：" + (j == 1));
19     }
20 
21     //构造体
22     public Father(){
23         System.out.println("父类的构造体：");
24     }
25 
26     public static void main(String[] args){
27         new Father();
28     }
29 }

这是子类代码

 1 package src;
 2 
 3 import java.text.SimpleDateFormat;
 4 import java.util.Date;
 5 import java.util.regex.Matcher;
 6 import java.util.regex.Pattern;
 7 
 8 public class Child extends Father{
 9 
10     //成员变量
11     private int i = 1;
12 
13     //非静态代码块
14     {
15         System.out.println("这是子类非静态代码块：" + (i == 1));
16     }
17 
18     //静态变量
19     private static int j = 1;
20 
21     //静态方法
22     static {
23         System.out.println("这是子类静态方法：" + (j == 1));
24     }
25 
26     //构造体
27     public Child(){
28         System.out.println("这是子类构造体：");
29     }
30 
31     public static void main(String[] args){
32         new Child();
33     }
34 }

运行结果

结论：由此可以看出父类的静态成员是先于子类的静态成员加载，而父类的非静态成员也是先于子类的非静态成员加载