Java类加载顺序

先导知识：

类加载时，从上往下先执行静态初始化语句，初始化块
创建类对象时，从上到下先执行非静态初始化语句，初始化块，最后执行构造方法；
静态的资源属于类所有，在类加载时就要分配内存空间。而非静态资源属于对象所有，只有在实例化时才会分配内存空间；
先类加载后创建对象
在类加载过程中遇到对象创建，则按照对象创建执行顺序。

初级：

已经标注执行顺序：
类加载–静态变量、静态方法–>创建类对象–非静态变量 / 非静态代码块 - - - > 构造器

public class Strings {
    public static void main(String[] args) {
        Loading loading =new Loading("位置");///2
    

    }
}

public class Loading {
    private static int k = 9;
    private static int n = 99;
    private static int i = printStr("i"); ///1
    {
        printStr("构造块");///2
    }
    //含参数构造方法
    public Loading(String str) {///3
        System.out.println((k++) + ": " + str + "   i=" + i + "    n=" + n);
        ++i;
        ++n;
        printlnStr("构造器内：非静态方法");
    }
    //静态方法
    public static int printStr(String str) {
        System.out.println((k++) + ":" +" 当前位置：" +str + "   i=" + i + "    n=" + n);
        ++n;
        return ++i;
    }
    //非静态方法
    public  int printlnStr(String str) {///4
        System.out.println((k++) + ":" +" 当前位置：" +str + "   i=" + i + "    n=" + n);
        ++n;
        return ++i;
    }

}

执行结果

9: 当前位置：i   i=0    n=99   //类加载
10: 当前位置：构造块   i=1    n=100
11: 对象   i=2    n=101
12: 当前位置：构造器内：非静态方法   i=3    n=102

进阶：

    private static int k = 9;
    private static Loading t1 = new Loading("类加载中创建对象t1");
    private static int i = printStr("i");
    private static int n = 99;
    {
        printStr("构造块");
        j=100;
    }
    private int j = printStr("j");
    public static int printStr(String str) {
        System.out.println((k++) + ":" +" 当前位置：" +str + "   i=" + i + "    n=" + n);
        ++n;
        return ++i;
    }
    public Loading(String str) {
        System.out.println((k++) + ": " + str + "   i=" + i + "    n=" + n);
        ++i;
        ++n;
    }
    static {
        printStr("静态块");
        n=100;
    }

    public static void main(String[] args) {
        System.out.println("wxt");
        Loading loading =new Loading("位置");

    }

进阶与初级对比：
进阶main方法放在当前类内部：需要先加载完类，才能执行main方法

• 类加载按照从上到下执行静态初始化，
• 遇到类内部有一个创建对象——那么就需要按照从上到下执行非静态的代码块

•  由于此时i 和n还没有赋值，则初值为0
  

•  先执行非静态初始化块，再执行构造方法
  

9: 当前位置：构造块   i=0    n=0
10: 当前位置：j   i=1    n=1
11: 类加载中创建对象t1   i=2    n=2

• 类内部创建对象结束后，继续从上到下执行静态变量和静态方法

12: 当前位置：i   i=3    n=3
13: 当前位置：静态块   i=4    n=99

• 类加载完毕后进入main方法

•  创建实例对象，——那么就需要按照从上到下执行非静态的代码块
  

•  		先执行非静态初始化块，再执行构造方法
  

执行结果

9: 当前位置：构造块   i=0    n=0
10: 当前位置：j   i=1    n=1
11: 类加载中创建对象t1   i=2    n=2
12: 当前位置：i   i=3    n=3
13: 当前位置：静态块   i=4    n=99
wxt
14: 当前位置：构造块   i=5    n=100
15: 当前位置：j   i=6    n=101
16: 位置   i=7    n=102

总结

；类加载时，从上往下先执行静态初始化语句，静态初始化块
；创建类对象时，从上到下先执行非静态初始化语句，初始化块，最后执行构造方法；
；先类加载后创建对象
；在类加载过程中遇到对象创建，则按照对象创建时的执行顺序，然后再继续进行类加载的执行顺序