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()方法执行下面的语句
为了说明类与静态代码是相关的,即类如果已经被加载了,再次加载类时,静态代码块也不会再次初始化。
![](/qrcode.jpg)
修改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的底层加载才是真理呀!