类加载器

类加载器的生命周期

在以下几种情况会结束生命

• 程序执行完毕
• 执行了system.exit（）方法
• 程序在运行期间出现了异常或错误
• 操作系统出现异常导致虚拟机的结束

类的加载连接与初始化

（还有使用和卸载，这两个用的比较少）
加载：查找并加载类的二进制数据
连接：连接又分为三种
验证：确保加载类的正确性
准备：为类的静态变量开辟内存空间，并赋默认值
解析：将符号引用转换成直接引用
初始化：将类的静态变量赋予正确的初始值
类实例化：
为对象分配内存
为实例变量赋默认值
为实例变量赋值正确的初始值
java编译器为它编译的每一个类都至少生成一个实例初始化方法，在java的class文件中，这个实例初始化方法被称为“”。针对源代码中每一个类的构造方方法，java编译器都产生一个 方法,静态的也会有一个初始化方法，但是不叫inti
垃圾回收和对象中结

Java程序对类的使用可以分为两种：主动使用和被动使用
所有的java虚拟机实现必须在每个类或接口被java程序“首次主动使用”时才初始化他们
主动使用：
1. 对类或接口中静态变量的引用或赋值
2. 操作静态方法
3. 创建本类的实例
4. 创建子类的实例
5. 反射，如Class.forName（）
6. java虚拟机启动时被标为启动类的类（如有main()方法的类，java Test）
7. jdk1.7开始提供的动态语言支持：java.lang.invoke.MethodHandle实例的解析结果REF_getStatic,REF_putStatic,REF_invokeStatic句柄对应的类没有初始化，则初始化
除了以上7种外其他的都会看成被动使用，都不会导致类的初始化
助记符：getstatic,putstatic,invokestatic

类的加载
类的加载是指将类的.class文件中的二进制数据读入到内存中，将其放在运行时数据区的方法区内，然后在内存中创建一个java.lang.class对象（规范并未说明Class对象位于哪里，HotSpot虚拟机将其放在了方法区内）用来封装类在方法区内的数据结构.
加载.class文件的方式
1. 从本地系统直接读取
2. 从网络上下载.class文件
3. 从jar、zip等归档文件中加载.class文件
4. 从专有数据库中提取.class文件
5. 将java源文件动态编译成.class文件（如动态代理、jsp）

/*
    对于一个静态字段来说，只有直接定义了该字段的类才会被初始化，
    当一个类在初始化时，要求其父类全部都已经初始化完毕。
    -XX:+TraceClassLoading 用于追踪类的加载信息并打印出来
    
    -XX:+<option>  表示开启option选项
    -XX:-<option>  表示关闭option选项
    -XX:<option>=<value> 表示将option选项的值设置为value
*/
public class MyTest1 {
    public static void main(String[] args) {
        System.out.println(MyChild1.str);
    }
}
class MyParent1{
    public static String str = "hello world";
    static {
        System.out.println("I am is MyParent");
    }
}

class MyChild1 extends MyParent1{
    public static String str2= "child";
    static {
        System.out.println("I am is MyChild1");
    }
}

可以在idea的Terminal中反编译一下.class文件看一下结果

/*
    常量在编译阶段会存入到调用这个常量的方法所在的类的常量池中
    本质上，调用类并没有直接引用到定义常量的类，因此并不会触发定义常量的类的初始化
    注意：这里指的时将常量存放到了MyTest2的常量池中，之后MyTest2与MyParent2就没有任何关系了
    甚至可以将MyParent2的class的文件删除
    
    助记符：
        ldc表示将int，float或是String类型的常量值从常量池中推送至栈顶
        bipust表示将单字节（-128~127）的常量值推送至栈顶
        sipust表示将一个短整型常量值（-32768~32767）推送至栈顶
        iconst_1表示将int类型1推送至栈顶（iconst_m1~iconst_5）
*/
public class MyTest2 {
    public static void main(String[] args) {
        System.out.println(MyParent2.str);
    }
}

class MyParent2{
    public static final String str = "hello world";
    public static final short s = 127;
    public static final int i = 128;
    public static final int j = 5;

    static {
        System.out.println("I am MyParent2");
    }
}

编译期常量与运行期常量的区别及数组创建本质*

/*
当一个常量的值并非变异期间可以确定的，那么其值就不会被放到调用类的常量池中
这时在程序运行时，会导致主动使用这个常量所在的类，显然会导致这个类被初始化
*/
public class MyTest3 {
    public static void main(String[] args) {
        System.out.println(MyParent3.str);
    }
}

class MyParent3{
    public static final String str =UUID.randomUUID().toString();
    static {
        System.out.println("MyParent3");
    }
}

运行结果：
MyParent3
9492e92d-1b72-45af-8ac5-98944926f621

/*
    首次使用时才会初始化
    对于数组实例来说，其类型是由JVM在运行期动态生成的，表示为[Lcom.boya.classloader.MyParent4这种形式
    动态生成的类型，其父类型就是object

    对于数组来说，JavaDoc经常构成数组的元素为Component，实际上就是将数组降低一个维度后的类型
    
    助记符：
    anewarray:表示创建一个引用类型的（如类、接口、数组）数组，并将其引用值压入栈顶
    newarray:表示创建一个制定的原始类型（如int、float、char）数组，并将其引用值压入栈顶
*/
public class MyTest4 {
    public static void main(String[] args) {
        MyParent4 myParent4 = new MyParent4();
        System.out.println("========");
        MyParent4 myParent5 = new MyParent4();

        MyParent4[] myParent4s = new MyParent4[1];
        System.out.println(myParent4s.getClass());

        MyParent4[][] myParent4s1 = new MyParent4[1][1];
        System.out.println(myParent4s1.getClass());

        System.out.println(myParent4.getClass().getSuperclass());
        System.out.println(myParent4s1.getClass().getSuperclass());

        System.out.println("=====");

        int[] ints = new int[1];
        System.out.println(ints.getClass());
        System.out.println(ints.getClass().getSuperclass());
    }
}

class MyParent4{
    static {
        System.out.println("MyParent4");
    }
}
结果：
MyParent4
========
class [Lcom.boya.classloader.MyParent4;
class [[Lcom.boya.classloader.MyParent4;
class java.lang.Object
class java.lang.Object
=====
class [I
class java.lang.Object

接口初始化规则与类加载器准备阶段和初始化阶段的重要意义

/*
    当一个接口在初始化时，并不要求其父类接口都完成了初始化
    只有在真正使用到父类接口时（如引用接口中定义的常量时），才会初始化
    可以通过删除编译后的.class文件来测试
*/
public class MyTest5 {
    public static void main(String[] args) {
        System.out.println(MyChild5.b);
    }
}

interface MyParent5{
    public static final int a = 5;
}

interface MyChild5 extends MyParent5{
    //public static final int b = 6;
    public static final int b = new Random().nextInt(4);
}

/*
    这里用到的主要知识点就是加载、连接、初始化的顺序，还有主动使用导致的初始化，挺重要的，可以通过测试各种情况来体验一下
*/
public class MtTest6 {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        System.out.println("counter1:"+Singleton.counter1);
        System.out.println("counter2:"+Singleton.counter2);
    }
}

class Singleton{
    public static int counter1;
    //public static int counter2 = 0;
    private static Singleton singleton = new Singleton();

    private Singleton(){
        counter1++;
        counter2++;
        System.out.println(counter1);
        System.out.println(counter2);
    }

    public static int counter2 = 0;
    public static Singleton getInstance(){
        return singleton;
    }
}

类加载器深入解析及重要特性解析

有两种类型的类加载器
java虚拟机自带的加载器
* 根类加载器（Bootstrap）
* 扩展类加载器（Extension）
* 系统（应用）类加载器（System）

用户自定义的类加载器
* java.lang.ClassLoader的子类
* 用户可以定制类的加载方式

类加载器并不需要等到某个类被“首次主动使用”时再加载它
JVM规范允许类加载器在预料某个类将要被使用时就预先加载它，如果在预先加载的过程中遇到了.class文件缺失或存在错误，类加载器必须在程序首次主动使用该类时才报告错误（LinkageError错误）
如果这个类一直没有被程序主动使用，那么类加载器就不会报告错误
类的验证：
类被加载后，就进入连接阶段，连接就是将已经读入到内存的类的二进制数据合并到虚拟机的运行时环境中去。
验证的内容：
* 类文件的结构检查
* 语义检查
* 字节码验证
* 二进制兼容性的验证
类的准备：

类的初始化：


类的初始化步骤：

• 假如这个类还没有被加载还连接，那就先进行加载和连接
• 加入类存在直接父类，并且这个父类还没有被初始化，那就先初始化直接父类
• 加入类中存在初始化语句，那就一次执行这些初始化语句

类的初始化时机

只有当程序访问的静态变量或静态方法确实在当前类或当前接口中定义时，才可以认为时对类或接口的主动使用
调用ClassLoader类的loadClass方法加载一个类，并不是对类的主动使用，不会导致类的初始化。

类加载器：


除了以上虚拟机自带的类加载器外，用户还可以定制自己的类加载器。java提供了抽象类java.lang.ClassLoader，所有用户自定义的类加载器都应该继承ClassLoader类

根类加载器，扩展类加载器，系统类加载器，自定义类加载器，他们不是继承的关系，是包含的关系，下面的加载器包含上面的加载器