一、阿里巴巴笔试题：
public class T implements Cloneable {
public static int k = 0;
public static T t1 = new T("t1");
public static T t2 = new T("t2");
public static int i = print("i");
public static int n = 99;
public int j = print("j");
{
print("构造快");
}
static {
print("静态块");
}
public T(String str) {
System.out.println((++k) + ":" + str + " i=" + i + " n=" + n);
++n;
++i;
}
public static int print(String str) {
System.out.println((++k) + ":" + str + " i=" + i + " n=" + n);
++n;
return ++i;
}
public static void main(String[] args) {
T t = new T("init");
}
}
当.java源代码转换成一个.class文件后，其转换成类似下面的等价代码：
public class T implements Cloneable {
public static int k;
public static T t1;
public static T t2;
public static int i;
public static int n;
static {
k = 0;
t1 = new T("t1");
t2 = new T("t2");
i = print("i");
n = 99;
print("静态块");
}
public int j;
public T(String str) {
j = print("j");
print("构造快"); // 最终的构造方法是这个样子
System.out.println((++k) + ":" + str + " i=" + i + " n=" + n);
++n;
++i;
}
public static int print(String str) {
System.out.println((++k) + ":" + str + " i=" + i + " n=" + n);
++n;
return ++i;
}
public static void main(String[] args) {
T t = new T("init");
}
}
二、运行结果
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
三、加载过程分析
一、执行main（）时，由于使用new语句创建实例，属于首次主动使用类T，JVM加载类T，
声明静态变量k、t1、t2、i、n（为静态变量分配内存），并设置变量初始化的值（0，null，null，0，0） --- 类生命周期的准备阶段
在static代码块中对k进行第二次赋值，k=0；
在static代码块中对t1进行第二次赋值，触发new T（“t1”）的实例化过程 --- 静态变量的初始化可以在声明处进行，也可以在静态代码块进行
- 声明实例变量j，并设置变量初始化的值0，然后进入构造方法public T （String str）构造方法执行完毕，将heap区中创建的T的实例对象，并赋值给t1
- 执行静态方法print（"j"），并将返回值赋值给j，print（）方法输出“1:j i=0 n=0”，返回值为1；并完成j=1的赋值
- 执行静态方法print（"构造块"）,print（）方法输出“2:构造快 i=1 n=1”，返回值为2
- 执行构造方法的剩下三行，即
System.out.println((++k) + ":" + str + " i=" + i + " n=" + n);
++n;
++i;
# 此时str的值是构造方法的传参“t1”，最终输出“3:t1 i=2 n=2”- 在static代码块中对t2进行第二次赋值，触发new T（“t2”）的实例化过程，由于k，i，n是静态变量，自增操作的值都被保留了下来。输出：
4:j i=3 n=3
5:构造快 i=4 n=4
6:t2 i=5 n=5执行语句 i = print（“i”），输出
7:i i=6 n=6 # print（“i”）返回值为6，赋值给i执行n=99；print（“静态块”），输出
8:静态块 i=7 n=99 #因为n=99的赋值语句，输出成为了n=99至此，类初始化完毕。
二、完成类T的加载后，然后进行new T("init")的创建类T的实例，
过程和前几次new T("t1")、new T("t2")基本相同，输出
9:j i=8 n=100
10:构造快 i=9 n=101
11:init i=10 n=102实例化操作3次 * 3 + print（“i”） + print（“静态块”），共计输出11行内容
四、涉及知识点
主动使用：
1)：最为常用的new一个类的实例对象，或者通过反射/克隆/反序列化手段来创建实例。
2)：直接调用类的静态方法（也包括main方法）。
3)：操作（访问或改变）该类或接口中声明的非编译期常量静态字段（对于final类型的静态变量,如果在编译时就能计算出变量的取值,那么这种变量被看做编译时常量，不视作主动使用）
4)：调用Java API的某些反射方法,比如调用Class.forName("ClassName")
5)：初始化一个类的子类的时候，父类也相当于被程序主动调用了(如果调用子类的静态变量是从父类继承过来并没有覆写的，那么也就相当于只用到了父类的静态变量，和子类无关，所以这个时候子类不需要进行类初始化)。
6)：JVM虚拟机启动时被标为启动类的类.
所有的JVM实现，在首次主动使用某类的时候才会加载该类。
被动使用：
- 父接口并不会因为它的子接口或者实现类的初始化而初始化. 只有当程序首次使用特定接口的静态变量时,才会导致该接口的初始化.
- 通过数组定义来引用类，不会触发类的初始化，如SubClass[] sca = new SubClass[10];
- Java程序中对类的编译时常量的使用,被看做是对类的被动使用,不会导致类的初始化.（对于final类型的静态变量,如果在编译时就能计算出变量的取值,那么这种变量被看做编译时常量.）
- 如果调用子类的静态变量是从父类继承过来并没有覆写的，那么也就相当于只用到了父类的静态变量，和子类无关，所以这个时候子类不需要进行类初始化)。
自增运算：
int i = 0; System.out.println(i++); System.out.println(i) # 输出0和1 int i = 0; System.out.println(i++); System.out.println(i) # 输出1和1
其他：
对于类的成员变量，不管程序有没有显式地进行初始化，JVM都会先自动给它初始化为默认值。
局部变量声明以后，JVM不会自动地为它初始化为默认值，必须先经过显式的初始化才能使用它。如果编译器确认一个局部变量在使用之前可能没有被初始化，编译器将报错。
数组和String字符串都不是基本数据类型，它们被当作类来处理，是引用数据类型。引用数据类型的默认初始值都是null
参考：
Java Tutor - Visualize Java code execution to learn Java online (also visualize Python, Java, JavaScript, TypeScript, Ruby, C, and C++ code)