Java类中各模块的加载顺序只是表象，但至于为什么我们需要理解JVM的加载本质原理。
话不多说，上代码，从分析代码开始：
public class Test1 {
static{
System.out.println("这是静态代码块");
}
{
System.out.println("这是普通代码块");
}
public static void method(){
System.out.println("这是一个静态方法");
}
public void method2(){
System.out.println("这是一个普通方法");
}
public Test1(){
System.out.println("这是一个无参构造方法");
}
public static void main(String[] args) {
}
}
运行结果为：
这是静态代码块
分析如下：
首先，JVM在加载类的时候先找一个类的main()方法，这也是一个类的入口，如果没有main()方法，这个类将无法执行。所以main()方法是类加载的前提。但是不是说，有了main()方法就必须先执行main()方法里面的代码，这是大错特错的，就比如说你去打扫一个房间，房间的门牌号是你找到房间的前提。但是找到房间后并不是要先打扫门口的位置。
找到main()方法后，JVM开始初始化类，而static修饰的代码块，是根据类加载而加载的，并且只会加载依次，下次再加载这个类时，因为类已经被加载过了，所以static代码块也已经加载过了，所以不会再次执行static代码块。而普通代码块和构造方法是与对象有关的，而所有的代码都没有对象的产生，所以也不会执行这些代码，所以非静态代码全都没有执行。虽然有被静态修饰的方法，但是方法不调用不执行，所以输出结果里没有方法的结果。
我们接着尝试创建对象：
代码如下：
public static void main(String[] args) {
Test1 t=new Test1();
}
程序运行结果如下：
这是静态代码块
这是普通代码块
这是一个无参构造方法
分析如下：
正如我们上面说的那样，JVM在找到main方法后，开始初始化类，执行静态代码块，然后回到main()方法，执行main()方法里面的代码， 创建对象后，程序中的非静态代码块和构造方法相继执行，完成后回到main()方法，再执行main()方法下面的程序，我们可以修改下main()方法验证下。
main（）方法如下：
public static void main(String[] args) {
System.out.println("Hello");
Test1 t=new Test1();
System.out.println("World");
}
结果如下：
这是静态代码块
Hello
这是普通代码块
这是一个无参构造方法
World
输出结果证明了我们的想法，那就是：
找到main()方法 —> 初始化静态代码块 —> 回到main()方法 —>执行main()方法里面的程序，创建对象 —> 执行非静态代码和构造方法 —> 再回到main()方法执行下面的语句
为了说明类与静态代码是相关的，即类如果已经被加载了，再次加载类时，静态代码块也不会再次初始化。
修改main()方法如下：
public static void main(String[] args) {
Test1 t=new Test1();
Test1 tt=new Test1();
}
运行结果如下：
这是静态代码块
这是普通代码块
这是一个无参构造方法
这是普通代码块
这是一个无参构造方法
分析如下：
虽然连续创建了两次对象，但类在找到main()方法后已经被加载过了，静态代码块也就是在这个时候加载的，再次创建对象时，只执行跟对象有关的代码块，所以静态代码块跟类有关，只会跟类一起加载一次，而非静态代码快随着对象的创建而不断加载。
是不是感觉已经明白的差不多了，别着急，我们在看一个程序：
public class Test1 {
static Test1 t1=new Test1();
static{
System.out.println("这是静态代码块");
}
{
System.out.println("这是普通代码块");
}
public static void method(){
System.out.println("这是一个静态方法");
}
public void method2(){
System.out.println("这是一个普通方法");
}
public Test1(){
System.out.println("这是一个无参构造方法");
}
public static void main(String[] args) {
}
}
运行结果如下：
这是普通代码块
这是一个无参构造方法
这是静态代码块
代码分析如下：
JVM在找到main()方法后，初始化类，去执行静态代码，而静态代码刚好是一个创建对象的过程，我们又知道非静态代码才是跟对象有关的，所以会再次进入这个类去寻找非静态代码块，所以我们看到的结果是先输出了普通代码块和构造方法，创建对象完成后，JVM继续初始化类，第一个静态代码已经执行完毕，接下类执行下一个静态代码块，也就是我们看到的输出了静态代码块。然后回到main()方法，main()方法里面没有内容，所以程序运行结束。
如果我们在main()里面创建一个对象会怎么样呢？
修改main()方法如下：
public static void main(String[] args) {
Test1 t=new Test1();
}
运行结果如下：
这是普通代码块
这是一个无参构造方法
这是静态代码块
这是普通代码块
这是一个无参构造方法
分析如下：
前三个输出结果如我们预料的一样，当回到main()方法时，创建对象，就执行非静态代码，那么就会输出后两行结果。
如果我们仔细观察会发现，static Test1 t1=new Test1()这行代码为什么不是死循环呢，因为new Test1()会进入Test1()类，但是只会执行非静态代码，也就是不会再执行new Test1()了，所以自然不会死循环。但是如果去掉static那么我们看一下结果：
这是静态代码块
Exception in thread "main" java.lang.StackOverflowError
at test.Test1.<init>
....
....
会报错，是因为无限制创建对象的结果，因为在执行完静态代码后，创建对象后会继续执行非静态代码，然后再创建对象，再执行非静态代码…如此循环下去，内存被耗完，所以就会报错。
再考虑一种情况，有两个类：
class Test2 {
static{
System.out.println("这是静态代码块");
}
{
System.out.println("这是普通代码块");
}
public static void method(){
System.out.println("这是一个静态方法");
}
public void method2(){
System.out.println("这是一个普通方法");
}
public Test2(){
System.out.println("这是一个无参构造方法");
}
public static void main(String[] args) {
System.out.println("hhellp");
Test1 t=new Test1();
}
}
public class Test1{
public static void main(String[] args) {
Test2 t=new Test2();
Test2 tt=new Test2();
}
}
运行结果为：
这是静态代码块
这是普通代码块
这是一个无参构造方法
这是普通代码块
这是一个无参构造方法
代码分析：
JVM首先会加载main()方法所在的类，加载这个类的静态方法，发现没有后回到main()方法，执行这行代码 Test2 t=new Test2()，也就是创建Test2()的对象，所以JVM又要开始加载这个类，因为这个类之前没有被加载过，所以会先运行静态代码块来初始化类，然后再运行普通代码块然后使用构造方法，这也是前三行的结果，然后再次回到main()方法，执行这行代码 Test2 t=new Test2()，然后发现Test2()这个类已经被JVM加载过了，所以不需要初始化类，直接调用非静态方法就可以了。
其实，上面说了那么多，就一个道理而已：
静态代码是与类有关的，类加载一次，静态代码也就只会加载一次。 非静态代码是与对象有关的，对象创建几次就执行几次。
加载顺序只是表象，而JVM的底层加载才是真理呀！