关于Java 在new对象时的执行顺序的一道题

执行顺序

1、父类的静态变量和静态块赋值（按照声明顺序） 　　
2、自身的静态变量和静态块赋值（按照声明顺序） 　　
3、main方法 　　
4、父类的成员变量和块赋值（按照声明顺序） 　　
5、父类构造器赋值 　　
6、自身成员变量和块赋值（按照声明顺序） 　　
7、自身构造器赋值 　　
8、静态方法，实例方法只有在调用的时候才会去执行

我在学习时遇到了一道题，记录一下。据听说是阿里的面试题

代码

public class Text {
 
    public static int k = 0;
    public static Text t1 = new Text("t1");
    public static Text t2 = new Text("t2");
    public static int i = print("i");
    public static int n = 99;
    public int j = print("j");
 
    {
        print("构造块");
    }
 
    static {
        print("静态块");
    }
 
    public Text(String str) {
        System.out.println((++k) + ":" + str + "   i=" + i + "    n=" + n);
        ++i;
        ++n;
    }
 
    public static int print(String str) {
        System.out.println((++k) + ":" + str + "   i=" + i + "    n=" + n);
        ++n;
        return ++i;
    }
 
    public static void main(String args[]) {
        Text t = new Text("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

解释

• 1. main方法开始执行，先进行Text的类加载。

2. 在Text类加载的准备阶段，为Text类的静态变量k, t1, t2, i以及n分配内存并设置静态变量的初始值（默认值）。
   其中基本数据类型为0 ，引用数据类型为null
3. 在类加载的初始化阶段，开始执行静态变量的赋值语句和static{}静态代码块，也就是()方法。
   这里有个细节：编译器会自动收集类中的所有静态变量的赋值动作和静态语句块（static{}代码块），
   收集的顺序是由语句在源文件中出现的顺序所决定的，
   静态语句块中只能访问到定义在静态语句块之前的变量，
   定义在它之后的变量，在前面的静态语句块可以赋值，但是不能访问。
   根据源代码的顺序，先给k赋值为0。
   接着为t1赋值，此时需要创建一个Text对象实例。
   根据实例变量/构造块/构造函数的执行顺序，
   先进行Text类的实例变量j的赋值，所以调用静态方法print(),输出：1:j i=0 n=0
   接着执行构造块中的 print(“构造块”); 语句，输出： 2:构造块 i=1 n=1
   再接着执行构造函数，输出： 3:t1 i=2 n=2
   再接着为t2赋值，此时还需要创建一个StaticTest对象实例。
   同样的，根据实例变量/构造块/构造函数的执行顺序，
   先进行Text类的实例变量j的赋值，所以调用静态方法print(),输出：4:j i=3 n=3
   接着执行构造块中的 print(“构造块”); 语句，输出： 5:构造块 i=4 n=4
   再接着执行构造函数，输出： 6:t2 i=5 n=5
   再接着为静态变量i赋值，执行 print(“i”) 语句，输出： 7:i i=6 n=6
   再接着为静态变量n赋值，赋值后n的值为99。此时没有任何输出内容。
   最后执行静态块中的 print(“静态块”) 语句，输出：8:静态块 i=7 n=99（因为上一步对n进行了重新赋值，所以此时n=99）
   至此，()方法 执行完毕，类加载结束。
4. 执行main方法中的 new Text(“init”) 语句，创建另一个Text对象实例
   同样的，根据实例变量/构造块/构造函数的执行顺序，
   先进行Text类的实例变量j的赋值，所以调用静态方法print(),输出：9:j i=8 n=100
   接着执行构造块中的 print(“构造块”); 语句，输出： 10:构造块 i=9 n=101
   再接着执行构造函数，输出： 11:init i=10 n=102

重点：

1. 静态变量，静态代码块，在类加载是执行，且一个类 new 多个实例时也只执行一次。
2. 静态方法，实例方法只有在调用的时候才会去执行
3. 当静态加载中遇到需要加载非静态的情况： 先加载非静态再加载静态（因为非静态可以访问静态，而静态不能访问非静态）

参考的网址

https://www.cnblogs.com/timetellu/p/11619158.html?ivk_sa=1024320u
https://www.liangzl.com/get-article-detail-218698.html
（基本上和上面两位大佬的内容一样，只要记忆，所以自己写了一个）