这个是我看到一个同学去面试，然后回来之后说的一道面试题，看了之后发现，简单的基础题也可以考倒不少人啊，先看看题吧。

1. public class Test01
   
2. {
   
3.         public static int k = 0;
   
4.         public static Test01 t1 = new Test01("t1");
   
5.         public static Test01 t2 = new Test01("t2");
   
6.         public static int i = print("i");
   
7.         public static int n = 99;
   
8.         public int j = print("j");
   
9.         {
   
10.                 print("构造块");
    
11.         }
    
12.         static {
    
13.                 print("静态块");
    
14.         }
    
15. 
    
16.         public Test01(String str) {
    
17.                 System.out.println((++k) + ":" + str + "   i=" + i + "   n=" + n);
    
18.                 ++i;
    
19.                 ++n;
    
20.         }
    
21. 
    
22.         public static int print(String str) {
    
23.                 System.out.println((++k) + ":" + str + "   i=" + i + "   n=" + n);
    
24.                 ++n;
    
25.                 return ++i;
    
26.         }
    
27. 
    
28.         public static void main(String[] args) {
    
29.                 Test01 t = new Test01("init");
    
30.         }
    
31. }

复制代码

要求写出运行结果。。。。。
结果是：
       1:j   i=0   n=0
       2:构造块   i=1   n=1
      3:t1   i=2   n=2
      4:j   i=3   n=3
      5:构造块   i=4   n=4
      6:t2   i=5   n=5
      7:i   i=6   n=6
      8:静态块   i=7   n=99
      9:j   i=8   n=100
      10:构造块   i=9   n=101
      11:init   i=10   n=102

开始看了之后确实一下子没有搞定，于是复习了一下基础，又认认真真的看了一遍代码
最后分析了一下：
这道题考的是静态代码块，构造代码块和静态变量等在程序中的执行顺序。
1:j   i=0   n=0
我们都知道在有静态变量的时候，程序会最先执行静态的，也就是最先执行
-->public static Test01 t1 = new Test01("t1");
那么这个代码会建立一个实例对象，也就是会先完成非静态成员变量的赋值也就是
-->public int j = print("j");
由于i当前还未赋值，所以默认值是0，那么
调用的方法会打印--> 1:j   i=0   n=0
2:构造块   i=1   n=1
成员变量的定义完成之后就会调用构造方法，如果有构造代码块就会先执行构造代码块也就是
-->print("构造块");
-->2:构造块   i=1   n=1
3:t1   i=2   n=2
这个时候就开始执行构造方法，也就是public Test01(String str)，到此第一个创建的静态实例已经完成。
第二个和第一个一样。
4:j   i=3   n=3
5:构造块   i=4   n=4
6:t2   i=5   n=5
7:i   i=6   n=6
接着是一个静态变量的赋值，
-->public static int i = print("i");
-->public static int n = 99;
之后n的值就变成了99了
8:静态块   i=7   n=99
接着执行后面的静态代码块
9:j   i=8   n=100
最后所有静态的部分执行玩了之后就到了主函数了
-->Test01 t = new Test01("init");
10:构造块   i=9   n=101
11:init   i=10   n=102
开始在看的时候也有点懵，不过之后自己理清顺序之后就蛮好理解了。

考的知识挺全

的确 ，考的是new之后jvm怎么来出来对象在内存中的分配，以及如何来初始化对象。new 之后到底程序发生了什么。。。。以前知道，但是没见过把类的静态初始化都考进来的，很全