不调试 还真不好理解，看着顺序慢慢分析，各位能解释下吗？

1. public class Test1 {
   
2.      public static int k=0;
   
3.      public static Test1 t1=new Test1("t1");
   
4.      public static Test1 t2=new Test1("t2");
   
5.      public static int i=print("i");
   
6.      public static int n=99;
   
7.    
   
8.      public int j=print("j");
   
9.    
   
10.     {
    
11.         print("构造块");
    
12.      }
    
13.    
    
14.     static{
    
15.        print("静态块");
    
16.     }
    
17.    
    
18.    public Test1(String str){
    
19.         System.out.println((++k)+":"+str+"    i="+i+"    n="+n);
    
20.         ++i;++n;
    
21.    }
    
22.    
    
23.     public static int print(String str){
    
24.          System.out.println((++k)+":"+str+"    i="+i+"    n="+n);
    
25.          ++n;
    
26.           return ++i;
    
27.     }
    
28.    
    
29.     public static void main(String...strings ){
    
30.         
    
31.   }
    
32. }
    
33. 
    
34. 输出结果：
    
35. 1:j    i=0    n=0
    
36. 2:构造块    i=1    n=1
    
37. 3:t1    i=2    n=2
    
38. 4:j    i=3    n=3
    
39. 5:构造块    i=4    n=4
    
40. 6:t2    i=5    n=5
    
41. 7:i    i=6    n=6
    
42. 8:静态块    i=7    n=99

复制代码

问题：i和n到底是什么时候声明的，public static Test1 t1=new Test1("t1");这句会去执行构造块和构造方法,但是这时候public static int i=print("i");并没执行，i是哪里出来的？它是按顺序先声明所有变量然后才从头再挨个赋值吗？

楼主的给出的代码很是犀利啊，根据对例子程序代码的运行，分析，我得出如下感悟，仅供参考：

类装载器在装载类的过程中，有一项工作是准备：给类的静态变量分配并初始化存储空间，这里的初始化存储空间应该是给静态变量赋予默认值。
类的装载完成后，才开始正式初始化，对于静态代码块和静态变量的初始化顺序，是和他们在程序中书写的前后顺序一致的。将静态代码块提到最前面测试：

1. public class Test2 {
   
2. 
   
3.         static{
   
4.        print("静态块"); /// 提到前面，先初始化，此时 i,n 均未进行定义值的初始化，所以输出的是默认值0。
   
5.     }
   
6.         public static int k=0;
   
7.         public static Test2 t1=new Test2("t1");
   
8.         public static Test2 t2=new Test2("t2");
   
9.         public static int i=print("i");
   
10.         public static int n=99;
    
11.        
    
12.         public int j=print("j");
    
13.    
    
14.     {
    
15.         print("构造块");
    
16.     }
    
17.    
    
18.     public Test2(String str){
    
19.         System.out.println((++k)+":"+str+"    i="+i+"    n="+n);
    
20.         ++i;++n;
    
21.     }
    
22.    
    
23.     public static int print(String str){
    
24.          System.out.println((++k)+":"+str+"    i="+i+"    n="+n);
    
25.          ++n;
    
26.           return ++i;
    
27.     }
    
28.    
    
29.     public static void main(String[] strings ){
    
30.         
    
31.   }
    
32. }
    

复制代码

结果：

1. 1:静态块    i=0    n=0
   
2. 1:j    i=1    n=1
   
3. 2:构造块    i=2    n=2
   
4. 3:t1    i=3    n=3
   
5. 4:j    i=4    n=4
   
6. 5:构造块    i=5    n=5
   
7. 6:t2    i=6    n=6
   
8. 7:i    i=7    n=7

复制代码

下面执行到 public static Test1 t1 = new Test1("t1");由于定义的静态变量 t1 是指向本类对象的引用，使得对象的初始化提前，和一般的类的初始化过程相去甚远。对象创建过程中，先默认值初始化成员变量，再定义值初始化成员变量，然后执行构造块，接着执行构造方法。对例子中的代码稍作 修改进行测试：

1. public class Test1 {
   
2. 
   
3.        
   
4.        
   
5.      public static int k=0;
   
6.          public static Test1 t2 = null;  /// 说明不是 Test1 t2 导致对象初始化提前。
   
7.      public static Test1 t1 = new Test1("t1");
   
8.      public static int i = print("i");
   
9.      public static int n = 99;
   
10.          
    
11.      public int j=print("j");
    
12.          public int b = print_1("b"); /// 这里赋值需要调用非静态方法。
    
13.          public int a = 100;          /// a 未来得及赋予 100 ，在 print_1中输出 默认值。
    
14.     {
    
15.         print("构造块");
    
16.      }
    
17.          
    
18.         static{
    
19.        
    
20.        print("静态块");
    
21.     }
    
22.    
    
23.    public Test1(String str){
    
24.         System.out.println((++k)+":"+str+"    i="+i+"    n="+n);
    
25.         ++i;++n;
    
26.    }
    
27.    
    
28.     public static int print(String str){
    
29.          System.out.println((++k)+":"+str+"    i="+i+"    n="+n );
    
30.          ++n;
    
31.           return ++i;
    
32.     }
    
33.        
    
34.     public int print_1(String str){    ///增加非静态方法，打印出的 a 为默认值：0.
    
35.          System.out.println((++k)+":"+str+"    i="+i+"    n="+n + "  a=" +a);
    
36.          ++n;
    
37.           return ++i;
    
38.     }
    
39.        
    
40.     public static void main(String[] strings ){
    
41.         
    
42.   }
    
43. }
    

复制代码

结果：

1. 1:j    i=0    n=0
   
2. 2:b    i=1    n=1  a=0
   
3. 3:构造块    i=2    n=2
   
4. 4:t1    i=3    n=3
   
5. 5:i    i=4    n=4
   
6. 6:静态块    i=5    n=99

复制代码

接下来安照正常的顺序，继续初始化其他静态变量，代码块，静态方法等等。

java类在装载的时候分几个阶段，
首先是.class字节码文件被装载到JVM中，在堆内存中为类的对象分配内存空间
然后就是java类的连接阶段，连接的时候有三个阶段。1：验证，2：准备，在这一阶段JVM会为类变量分配内存，并设置默认初始值，这一阶段不执行java代码。3：解析阶段。
最后才是对变量的实际初始化，这一阶段会为类的变量赋予真正的初始化值。而且是在首次主动使用该变量前才会初始化。

我觉得该帖子应当 给分