JVM学习笔记1_类加载与初始化
在java代码中，类型(class, interface, enum)的加载，连接，初始化过程都是在程序的运行期间完成的。
类型的加载最常见的情况是将磁盘上的class文件加载到内存中。
JVM与程序生命周期
在如下几种情况下， JVM将结束生命周期：
执行System.exit()方法
程序正常结束
程序在执行过程中遇到异常或错误而异常终止
操作系统出现错误导致JVM进程终止
类加载，连接，初始化顺序
加载：查找并加载二进制数据到内存中
连接：连接分为如下三个步骤
验证： 确保被加载类的正确定
准备：为类的
静态变量分配内存，并将其初始化为默认值解析：把类的符号引用替换为直接引用
初始化：为类的静态变量赋予
正确的初始值
java程序对类的使用方式分为两种：主动使用和被动使用。
所有的java虚拟机实现必须在每个类或接口首次主动使用时才会初始化他们，被动使用不会导致类的初始化。
主动使用分为如下几种情况：
创建类的实例，也就是new 一个对象
访问某个类或接口的静态变量， 或者对该静态变量赋值
调用类的静态方法
反射， 如Class.forName(“com.dcj.Test”)
初始化一个类的子类，也就是当初始化Child类时，Parent类会被主动使用
JVM启动时被标明为启动类的类（main方法的启动类）
类的加载
将类的class文件的二进制数据读入内存中，将其放在运行时数据区的方法区内，然后在内存中创建一个java.lang.Class对象，用来封装类在方法区内的数据结构。
加载class文件的方式如下：
从本地系统中加载
通过网络下载.class文件
从zip, jar 归档文件中加载
从数据库提取.class文件加载
将java源文件动态编译为.class文件（动态代理）
关于主动使用
考虑如下代码：
public class ClassLoaderTest1 {
public static void main(String[] args) {
//注意这一行
System.out.println(Child.str);
}
}
class Parent {
public static String str = "hello world";
static {
System.out.println("parent static block");
}
}
class Child extends Parent {
public static String str2 = "welcome";
static {
System.out.println("child static block");
}
}输出结果：
parent static block
hello world虽然打印的是Child.str， 但是Child类并未初始化。因为对于静态字段来说，只有直接定义了该字段的类才会被初始化。
稍稍改下代码：
public class ClassLoaderTest1 {
public static void main(String[] args) {
//这一行改了，打印Child.str2
System.out.println(Child.str2);
}
}
class Parent {
public static String str = "hello world";
static {
System.out.println("parent static block");
}
}
class Child extends Parent {
public static String str2 = "welcome";
static {
System.out.println("child static block");
}
}
输出结果如下：
parent static block
child static block
welcome这是因为打印Child.str2时， 会初始化Child类，但当初始化一个子类时，如果父类没有初始化，则先初始化父类。所以Parent类的静态代码块会先执行，接着Child类的静态代码块会先执行，最后打印出Child.str2的结果。
总结：
1. 对于静态字段来说，只有直接定义了该字段的类才会被初始化
2. 当一个类在初始化时，要求其父类全部初始化完毕。
关于JVM参数
规律：
首先以 -XX: 打头
-XX:+
-XX:+TraceClassLoading 可以追踪运行时哪些类被加载了。
final 初始化的特殊性
看如下代码：
public class ClassLoaderTest2 {
public static void main(String[] args) {
System.out.println(MyParent1.str);
}
}
class MyParent1 {
static final String str = "hello world";
static {
System.out.println("MyParent1 static block");
}
}运行结果如下：
hello world可以看到MyParent1 的静态代码块并未执行。
常量在编译阶段会存入到调用这个常量的方法的类的常量池中。本质上调用类并未直接引用到定义常量的类，不会触发定义常量的类的初始化。
再看一个例子：
public class ClassLoaderTest3 {
public static void main(String[] args) {
System.out.println(MyParent3.str);
}
}
class MyParent3 {
static final String str = UUID.randomUUID().toString();
static {
System.out.println("MyParent3 static block");
}
}输出结果如下：
MyParent3 static block
f85abad7-d5df-4cd2-8923-303c176cf53b跟上面的例子还是有区别的。这是因为当一个常量在编译期间不能够确定，那么它的值就不会放入常量池中， 运行时会导致主动使用这个常量所在的类，所以该类会初始化。
静态常量的类是否会初始化，跟静态常量本身的值在编译期间是否可以确定有关。
对象数组的特殊性
例子：
public class MyClassLoader4 {
public static void main(String[] args) {
//MyTest4 myTest4 = new MyTest4();
MyTest4[] arrs = new MyTest4[2];
System.out.println(arrs.getClass());
System.out.println(args.getClass().getSuperclass());
System.out.println("=============");
int[] intArr = new int[1];
System.out.println(intArr.getClass());
System.out.println(intArr.getClass().getSuperclass());
System.out.println("=============");
char[] charArr = new char[1];
System.out.println(charArr.getClass());
System.out.println("=============");
boolean[] boolArr = new boolean[1];
System.out.println(boolArr.getClass());
System.out.println("=============");
short[] shortArr = new short[1];
System.out.println(shortArr.getClass());
System.out.println("=============");
String[] stringArr = new String[1];
System.out.println(stringArr.getClass());
}
}
class MyTest4 {
static {
System.out.println("MyTest4 static block");
}
}运行结果如下：
class [Lclassloader.MyTest4;
class java.lang.Object
=============
class [I
class java.lang.Object
=============
class [C
=============
class [Z
=============
class [S
=============
class [Ljava.lang.String;对照着结果看，MyTest4 类并未初始化。
数组实例的类型是由JVM运行期动态生成的，表示为class [Lclassloader.MyTest4; ，动态生成的类型，其父类就是Object。
当创建一个引用类型的数组时，其引用类型对应的类并不会初始化。