这个很简单的证明，因为记性不好，老是把这些东西忘了，
看到一本书叫java入门到精通，里面的一段代码，改写一下，加入了构造代码块，并进行了简单说明
插入代码：

1. package ch01;
   
2. 
   
3. public class Test {
   
4.         //静态变量
   
5.         static String a = "string-a";
   
6.         static String b;
   
7.         //非静态变量
   
8.         String c = "string-c";
   
9.         String d;
   
10.         //静态代码块
    
11.         static {
    
12.                 printStatic("1");
    
13.                 b = "string-b";
    
14.                 printStatic("2");
    
15.         }
    
16.         public static void printStatic(String title){
    
17.                 System.out.println("-------"+title+"-------");
    
18.                 System.out.println("a=\""+a+"\"");
    
19.                 System.out.println("b=\""+b+"\"");
    
20.         }
    
21.         //构造代码块
    
22.         {
    
23.                 print("3");
    
24.                 d = "string-d";
    
25.                 print("4");
    
26.         }
    
27.         //构造函数
    
28.         public Test(){
    
29.                 print("5");
    
30.         }
    
31.         public void print(String title){
    
32.                 System.out.println("-------"+title+"-------");
    
33.                 System.out.println("a=\""+a+"\"");
    
34.                 System.out.println("b=\""+b+"\"");
    
35.                 System.out.println("c=\""+c+"\"");
    
36.                 System.out.println("d=\""+d+"\"");
    
37.         }
    
38.         public static void main(String[] args){
    
39.                 new Test();
    
40.         }
    
41. }
    

复制代码

结果是这个：
-------1-------
a="string-a"
b="null"
-------2-------
a="string-a"
b="string-b"
-------3-------
a="string-a"
b="string-b"
c="string-c"
d="null"
-------4-------
a="string-a"
b="string-b"
c="string-c"
d="string-d"
-------5-------
a="string-a"
b="string-b"
c="string-c"
d="string-d"
小程序一枚，说明了构造代码块，构造函数，静态代码块，静态变量，非静态变量在实例化时运行的顺序。
顺序是：静态变量→静态代码块→非静态变量→构造代码块→构造函数。
以上，如果有问题希望指正。

学习，有心了

学习学习。。。。

来学习学习。。

感谢分享

楼主的证明是错误的。初始化顺序确实很绕，其中的细节我一时也说不全，就提一点吧：静态变量/静态初始化块 的初始化顺序，并不是固定的，而是看在代码中出现的先后顺序。 实例变量/初始化块也是类似。因此，只要把楼主的代码顺序稍微一换，结果就不一样了：

1. public class Test {
   
2. //静态代码块
   
3.         static {
   
4.                 printStatic("1");
   
5.                 b = "string-b";
   
6.                 printStatic("2");
   
7.         }
   
8.         //静态变量
   
9.         static String a = "string-a";
   
10.         static String b;
    
11.         //非静态变量
    
12.         String c = "string-c";
    
13.         String d;
    
14.         
    
15.         public static void printStatic(String title){
    
16.                 System.out.println("-------"+title+"-------");
    
17.                 System.out.println("a=\""+a+"\"");
    
18.                 System.out.println("b=\""+b+"\"");
    
19.         }
    
20.         //构造代码块
    
21.         {
    
22.                 print("3");
    
23.                 d = "string-d";
    
24.                 print("4");
    
25.         }
    
26.         //构造函数
    
27.         public Test(){
    
28.                 print("5");
    
29.         }
    
30.         public void print(String title){
    
31.                 System.out.println("-------"+title+"-------");
    
32.                 System.out.println("a=\""+a+"\"");
    
33.                 System.out.println("b=\""+b+"\"");
    
34.                 System.out.println("c=\""+c+"\"");
    
35.                 System.out.println("d=\""+d+"\"");
    
36.         }
    
37.         public static void main(String[] args){
    
38.                 new Test();
    
39.         }
    
40. }
    

复制代码

输出变成：
-------1-------
a="null"
b="null"
-------2-------
a="null"
b="string-b"
这里静态初始化块在前，因此先执行静态初始化块。静态初始化块调用的printStatic函数用到了静态变量a、b，但只检查变量是否声明，而不进行初始化（代码顺序决定了此处静态变量初始化在静态初始化块之后），因此a、b都是null。接下来静态初始化块中对b进行了初始化，而a的初始化仍然没有执行，因此有了“---2---”的输出结果

PS 我无意贬低国产书，但IT方面的国产精品确实不多，初学者又难以分辨其中的错误。Java入门还是推荐Head First Java和Thinking in Java

学习学习

像楼主学习。

路过，加油！