Jvm（51），虚拟机类加载机制----类加载的时机

在了解下面的举的例子之前我们先来了解一下类的加载顺序？

 1 public class test1 {
 2     public static void main(String[] args) {
 3         C c = new C();
 4     }
 5 }
 6   
 7 class A{
 8     int a = 0;
 9     Method m = new Method(a);
10     static int a1 = 10;
11     static{
12         System.out.println("A:执行静态代码块A"+a1);
13     }
14      
15     {
16         System.out.println("非静态代码块A");
17     }
18   
19     public A(){
20         System.out.println("a:"+ a);
21     }
22 }
23   
24 class B extends A{
25     int b = 1;
26     Method m = new Method(b);
27     static int b1 = 20;
28     static{
29         System.out.println("B:执行静态代码块B"+b1);
30     }
31      
32     {
33         System.out.println("非静态代码块B");
34     }
35      
36     public B(){
37         System.out.println("b:"+ b);
38     }
39 }
40   
41 class C extends B{
42     int c = 2;
43     Method m = new Method(c);
44     static int c1 = 30;
45     static{
46         System.out.println("C:执行静态代码块C"+c1);
47     }
48      
49     {
50         System.out.println("非静态代码块C");
51     }
52      
53     public C(){
54         System.out.println("c:"+ c);
55     }
56 }
57   
58 class Method{
59     public Method(int i){
60         System.out.println("打印数据:" + i);
61     }

int a = 0; Method m = new Method(a); static int a1 = 10; static{ System.out.println("A:执行静态代码块A"+a1); } { System.out.println("非静态代码块A"); } public A(){ System.out.println("a:"+ a); } } class B extends A{ int b = 1; Method m = new Method(b); static int b1 = 20; static{ System.out.println("B:执行静态代码块B"+b1); } { System.out.println("非静态代码块B"); } public B(){ System.out.println("b:"+ b); } } class C extends B{ int c = 2; Method m = new Method(c); static int c1 = 30; static{ System.out.println("C:执行静态代码块C"+c1); } { System.out.println("非静态代码块C"); } public C(){ System.out.println("c:"+ c); } }

class Method{ public Method(int i){ System.out.println("打印数据:" + i); }

结果：

这里分析一下：在主函数创建类C的对象并初始化的过程：

1. C类继承B类、B类继承A类，A是B的父类，B是C的父类；
2. 调用A类的静态代码块和静态变量，打印"A:执行静态代码块A10"
3. 调用B类的静态代码块和静态变量，打印"B:执行静态代码块B20"
4. 调用C类的静态代码块和静态变量，打印"C:执行静态代码块C30"
5. 调用A类的普通成员变量和代码块，再调用A类的构造方法
6. 调用B类的普通成员变量和代码块，再调用B类的构造方法
7. 调用C类的普通成员变量和代码块，再调用C类的构造方法，打印完毕

这里我们可以看出类的初始化过程，首先按照顺序初始化父类中的静态变量和静态代码块，然后初始化子类中的静态变量和静态代码块，再就是初始化父类中的普通成员变量和代码块，再调用父类的构造方法，最后初始子类中的普通成员变量和代码块，再调用子类的构造方法。

好了我们来看下面的信息

类从被加载到虚拟机内存中开始，到卸载出内存为止，它的整个生命周期包括：加载（Loading）、验证

（Verification）、准备（Preparation）、解析（Resolution）、初始化（Initialization）、使用（Using）和卸载（Unloading）7个阶段。其中验证、准备、解析3个部分统称为连接（Linking），这7个阶段的发生顺序如图7-1所示。

图7-1中，加载、验证、准备、初始化和卸载这5个阶段的顺序是确定的，类的加载过程必须按照这种顺序按部就班地开始，而解析阶段则不一定：它在某些情况下可以在初始化阶段之后再开始，这是为了支持Java语言的运行时绑定（也称为动态绑定或晚期绑定）。注意，这里笔者写的是按部就班地"开始"，而不是按部就班地"进行"或"完成"，强调这点是因为这些阶段通常都是互相交叉地混合式进行的，通常会在一个阶段执行的过程中调用、激活另外一个阶段。

什么情况下需要开始类加载过程的第一个阶段：加载？Java虚拟机规范中并没有进行强制约束，这点可以交给虚拟机的具体实现来自由把握。但是对于初始化阶段，虚拟机规范则是严格规定了有且只有5种情况必须立即对类进行"初始化"（而加载、验证、准备自然需要在此之前开始）：

1. 遇到new、getstatic、putstatic或invokestatic这4条字节码指令时，如果类没有进行过初始化，则需要先触发其初始化。生成这4条指令的最常见的Java代码场景是：使用new关键字实例化对象的时候、读取或设置一个类的静态字段

（被final修饰、已在编译期把结果放入常

量池的静态字段除外）的时候，以及调用一个类的静态方法的时候。

1. 使用java.lang.reflect包的方法对类进行反射调用的时候，如果类没有进行过初始化，则需要先触发其初始化。
2. 当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。

package demo.jvm.test2; public class parent { static { System.out.println("我是父类的静态代码块"); } public parent() { System.out.println("我是父类的构造方法"); } } package demo.jvm.test2; public class Child extends parent {

static { System.out.println("我是子类的静态代码块"); } public Child() { System.out.println("我是子类的构造方法"); } } package demo.jvm.test2; public class Test { public static void main(String[] args) { Child c = new Child(); } } 我是父类的静态代码块我是子类的静态代码块我是父类的构造方法我是子类的构造方法

1. 当虚拟机启动时，用户需要指定一个要执行的主类（包含main（）方法的那个类），虚拟机会先初始化这个主类。
2. 当使用JDK 1.7的动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄，并且这个方法句柄所对应的类没有进行过初始化，则需要先触发其初始化。

对于这5种会触发类进行初始化的场景，虚拟机规范中使用了一个很强烈的限定语："有且只有"，这5种场景中的行为称为对一个类进行主动引用。除此之外，所有引用类的方式都不会触发初始化，称为被动引用

不会被初始化的情况：

1，通过子类引用父类的静态字段，子类不会被初始化

package demo.jvm.test3;

 

public class parent {

static {

System.out.println("我是父类的静态代码块");

}

 

public parent() {

System.out.println("我是父类的构造方法");

}

 

public static int num = 10;

}

package demo.jvm.test3;

public class Child extends parent { static { System.out.println("我是子类的静态代码块"); } public Child() { System.out.println("我是子类的构造方法"); } } package demo.jvm.test3; public class Test { public static void main(String[] args) { //构造方法是在类被初始化的时候才开始调用的，也就是new了之后才开始被调用的 //而这里没有被new Child的所以不会被初始化的。 //而静态代码块则是假如会被初始化的话则会在不需要new 对象的。 System.out.println(Child.num); } } 我是父类的静态代码块 10 //这里有一个小知识点要注意了，只有对象被new的时候才会调用它的无参的构造方法，而这里所讲的通过子类调用父类的静态字段，子类不会被初始化主要是通过观察静态代码块来观察的。

2，通过数组定义引用

package demo.jvm.test4; public class parent { static { System.out.println("我是父类的静态代码块"); } public parent() { System.out.println("我是父类的构造方法"); } public static int num = 10; } package demo.jvm.test4; public class Child extends parent { static {

System.out.println("我是子类的静态代码块"); } public Child() { System.out.println("我是子类的构造方法"); } } package demo.jvm.test4; public class Test { public static void main(String[] args) { Child[] c=new Child[10]; } } 这里什么都不会打印出来的。

3，调用类的常量

package demo.jvm.test5; public class parent { static { System.out.println("我是父类的静态代码块"); } public parent() { System.out.println("我是父类的构造方法"); } } package demo.jvm.test5; public class Child extends parent { static { System.out.println("我是子类的静态代码块"); } public Child() { System.out.println("我是子类的构造方法"); } public static final int num=20; } package demo.jvm.test5; public class Test { public static void main(String[] args) { System.out.println(Child.num);

} } 结果：20