类加载的”时机“与”过程“

写在前面：
虚拟机把描述类的数据从class文件记载到内存中，并对数据进行校验，转换解析，并且初始化，就是为了形成可以被虚拟机直接使用的java类型，这就是类加载机制。（这也恰恰解释了java语言的灵活性，因为.class文件之前是由什么语言写的我们不知道，所以实现了语言的多元化与包容性）

类加载的时机

虚拟机没有明确规定什么时候开始进行加载，但是却规定了什么时候必须对类进行初始化（但是很明显的知道就是，加载，验证，准备自然需要在初始化之前完成）

一。虚拟机严格规定的五种立即对类进行初始化：

1.new,getstatic,putstatic,invokestatic四条字节码指令：

遇到这四条字节码指令时，如果没有进行初始化，就必须立即对类进行初始化。生成这四条指令的情景：

1. 使用new关键字进行实例化对象
2. 读取或设置一个类的静态字段（被final修饰，已经被编译器把结果放到了常量池的静态字段除外）
3. 调用一个类的静态方法

2.对类进行反射调用：

使用java.lang.reflect包的方法对类进行反射调用的时候，如果类没有进行过初始化，则需要先触发其初始化

3.父类初始化在子类初始化之前：

当初始化一个类的时候，如果父类还没有进行初始化，则需要进行处罚父类的初始化

4.主类：

当虚拟机启动时，用户需要指定一个执行的主类，说白了就是有mian方法的类，虚拟机会先初始化这个类

5.大致了解：句柄：

jdk1.7,REF_getStatic的方法的句柄，对应的类没有进行初始化，就要先触发其进行初始化

以上五种场景中的行为称为对一个类进行主动引用。持此之外，所有的引用类的方式都不会触发类的初始化，陈伟被动引用

二。被动引用的例子：

A.通过子类引用父类的静态字段，不会导致子类初始化

public class SuperClass{
		static{
			System.out.println("SuperClass init");
			}
			public static int value = 123;
}

public class SubClass extends SuperClass{
		static{
			System.out.println("SubClass init");
			}
}

public class Main{
		public static void main(String[] args){
			System.out.println(SubClass.value);
			}
}

上面运行结果：SuperClass init而不会输出SubClass init是因为：
对于静态字段，只有直接定义这个字段的类才会被初始化，因此通过其子类来引用父类中定义的静态字段，只会触发父类的初始化而不会触发子类的初始化。

B.通过数组定义来引用类，不会触发此类的初始化

public class SuperClass{
		static{
			System.out.println("SuperClass init");
			}
			public static int value = 123;
}

public class Main{
		public static void main(String[] args){
			SuperClass[] sca = new SuperClass[10];
			}
}

输出结果没有SuperClass init是因为没有触发初始化，而是触发了另一个类：也叫SuperClass，对于用户代码来说这不是一个合法的类名称，但是他是由虚拟机自动生成，直接继承Object的类。
这个类代表了一个元素类型为SuperClass的一维数组，数组中的属性与方法只有public 修饰的length属性和clone方法可被用户直接使用。
java比C++安全是因为封装了对数组元素的访问方法，C++直接进行指针移动，而java直接检查报出越界

C.常量在编译期阶段存入常量池中，本质上并没有直接引用到定义常量的类，因此不会触发定义常量类的初始化

public class ConstClass{
			static{
				System.out.println("ConstClass init");
				}
		public static final String HELLOWORLD = "hello world";
}
public class Min{
public static void main(String[] args){
		System.out.println(ConstClass.HELLOWORLD);
		}
}

输出结果为：hello world，是因为编译器已经存储到常量池中，所以后面的使用不用涉及拥有该字段的类

三。补充：

接口的加载过程和类加载过程略不同，接口也有初始化，前面的例子都是static{}来输出初始化信息，但是接口中不允许有static{}修饰，但编译器依旧会为接口生成类构造器，用于初始化接口中定义的成员变量。
真正有区别的是：第三种，当一个类在初始化的时候要求其父类全部被初始化过了，但是一个接口在初始化时，并不要求父类接口都被初始化，是由真正用到父类接口才进行初始化

类加载的过程

一。加载：

“加载”是“类加载”的一个过程，不要混淆，分为以下三个过程：

1. 通过一个类的全限定名来获取定义此类的二进制字节流
2. 将这个字节流所代表的静态存储结构转换为方法区的运行时数据结构
3. 在内存中生成一个代表这个类的java.lang.Class对象，作为方法区对这个类的各种数据访问入口
   补充虚拟机没有明确规定二进制流要从哪里读取，哪里获取，所以相对于开放，以下为可以读取二进制字节流的地方：
   ZIP包中读取，也就是jar,war等
   网络中获取：Applet
   运行时计算产生，java.lang.reflect动态代理技术
   JSP文件
   数据库…

二。验证：

就是为了保证java虚拟机不会被代码恶意攻击而进行的验证，过程如下：

1.文件格式验证：

验证是否符合class文件格式：

1. 主，次版本等
2. 编码等
   第一阶段验证还有很多，不做详细介绍，目的就是为了保证输入的字节流能正确解析到方法区，这个验证就是验证二进制流，后面的验证都是对存储结构进行验证

2.元数据验证：

1. 这个类是否有父类
2. 这个类的父类是否继承了不允许继承的类（final）修饰
3. 如果这个类不是抽象类，是否实现了其父类或接口中所有的方法
4. 类中字段和方法是否与父类矛盾，也就是不符合一致性（如重载，参数方法一样，但是返回值不一样）
   主要目的就是对类的元数据信息进行语义校验，保证java语言规范的元数据信息

3.字节码验证

3.符号引用验证

三。准备：

准备阶段是正式为类变量分配内存并设置类变量初始值的阶段，这些变量所使用的内存都将在方法区中进行分配。
注意：这里是类变量，被static修饰的变量，而不是实例变量，实例变量将会随对象的实例化而分配在堆中，还有就是类变量的初始值如下：

举例如下：
public static int value = 123;
变量value在准备阶段过后初始值为0，因为这时候还没有执行任何java方法，而把value赋值为123是在后面初始化阶段，这个指令时putstatic指令。
public static final int value = 123;
这个结果就是123，是因为在编译器就会为value成生成ConstantValue属性，准备阶段就根据这个属性将value1赋值为123

四。解析：

1. 类或接口的解析
2. 字段解析
3. 类方法解析
4. 接口方法解析

五。初始化：

1. 首先明白：类构造器方法：
   由编译器自动收集所有类变量的赋值动作和静态代码块，编译器收集的顺序是：原文件中的顺序，静态语句块中只能访问定义在静态语句块之前的变量，定义在后面的变量只能在前面进行赋值，不可以进行访问：
   例子如下：

public class Test{
		static{
		i = 0;
		System.out.println(i);
		}
		static int i = 1;
}

结果就是非法向前引用变量

2. 与不一样：不会显式电泳父类构造器，保证子类之前父类方法执行，故第一个就是Object类
   由于父类的()方法先执行，也就意味着父类定义的静态代码块优先于子类的变量赋值操作，例子如下：

public class Parent{
public static int A = 1;
		static{
		A = 2;
		}		
}
static class Sub extends Parent{
		public static int B = A;
}
public static void main(String[] args){
		System.out.println(Sub.B);
}

输出结果为：2而不是1

补充：

虚拟机会保证一个类的在多线程下被正确加锁，同步，如果多个线程同时初始化一个类，那么是会有一个线程去执行这个类的()方法，其他的线程就只会阻塞等待，直到当前执行线程执行完毕，如果一个类耗时很长，就可能造成多个线程阻塞，这种阻塞很隐蔽！！！

写在最后，这是参考周老师的《JAVA虚拟机》进行总结，欢迎批评指正！！！