(目录)

类加载

动态加载 和 静态加载

反射机制是java实现动态语言的关键，也就是通过反射实现类动态加载。

1. 静态加载 : 编译时加载相关的类，如果没有则报错，依赖性太强
2. 动态加载 : 运行时加载需要的类,如果运行时不用该类，则不报错，降低了依赖性

类加载时机

1. 当创建对象时（new）——静态加载
2. 当子类被加载时，父类也加载——静态加载
3. 调用类中的静态成员时——静态加载
4. 通过反射——动态加载

静态加载：

编译的时候就会加载这个类(检查类是否正确、依赖关系、父类是否ok等等)，比如下面这段代码

用户可能输入1，也可能输入2，Dog类不一定会用到，静态加载不管那么多，它在编译的时候就会加载这个类，并且进行语法的校验

静态加载的依赖性较强

动态加载：

执行到这里才加载

因为new Dog(）是静态加载，因此必须编写Dog Person类是动态加载，所以，没有编写Person类也不会报错，只有当动态加载该类时，才会报错

类加载过程

加载和连接是JVM来完成的，我们无法控制，而初始化阶段就是我们自己可控的了（比如你在静态代码里面写什么内容是你自己可以控制的）

• 加载：将类的class文件读入到内存中，并为之创建一个java.lang.Class对象，此过程由类加载器完成
• 连接：将类的二进制数据合并到JRE中
• 验证阶段：对文件进行安全性校验，比如文件格式是否正确、元数据验证是否正确、字节码是否正确、符号引用是否正确
• 准备阶段：给静态变量分配内存，给静态变量默认初始化
• 解析阶段：虚拟机把常量池中的符号引用替换为直接引用
• 初始化阶段：静态代码块，静态变量显式赋值 初始化：JVM负责对类进行初始化，这里主要指静态成员

• 连接阶段-验证

1. 目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。
2. 包括:文件格式验证(是否以魔数oxcafebabe开头)、元数据验证、字节码验证和符号引用验证
3. 可以考虑使用-Xverify:none 参数来关闭大部分的类验证措施，缩短虚拟机类加载的时间。

连接阶段-准备

JVM会在该阶段对静态变量，分配内存并默认初始化(对应数据类型的默认初始值，如0、OL、null、false等)。这些变量所使用的内存都将在方法区中进行分配。

//类加载的连接阶段——准备
public class ClassLoad02 {
    public static void main(String[] args) {
        //...
    }
}

class A {
    //属性（成员变量，字段）
    //分析类加载的连接阶段——准备，属性是如何处理：
    //1. n1是成员变量，不是静态变量，因此在准备阶段，不会分配内存
    //2. n2是静态变量，分配内存，n2是默认初始化0，而不是20
    //3. n3是static final常量，和静态变量不一样，因为一旦赋值就不变，n3 = 30
    public int n1 = 10;
    public static int n2 = 20;
    public static final int n3 = 30;
}

连接阶段-解析

虚拟机将常量池内的符号引用替换为直接引用的过程。

Initialization（初始化)

1. 到初始化阶段，才真正开始执行类中定义的Java程序代码，此阶段是执行<clinit>0方法的过程。
2. <clinit>0方法是由编译器按语句在源文件中出现的顺序，依次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句,并进行合并。
3. 虚拟机会保证一个类的<clinit>)方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的<clinit>0方法，其他线程都需要阻塞等待，直到活动线程执行<clinit>0方法完毕[debug源码]

//类加载初始化阶段
public class ClassLoad03 {
    public static void main(String[] args) throws Exception {
        //1.加载B类，并生成对应的Class类对象
        //2.连接 num = 0;
        //3.初始化阶段：依次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句，并合并
        /*
            clinit(){
                System.out.println("B 静态代码块被执行");
                //num = 300;
                num = 100;
            }
            合并：num = 100;
         */

        //new B(); //类加载
        //System.out.println(B.num); //100，如果直接使用类的静态属性，也会导致类的加载

        //加载类的时候，是有同步机制控制
        /*
            protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
                //正因为有这个机制，才能保证某个类在内存中，只有一个 Class 对象
                synchronized (getClassLoadingLock(name)) {
                    //...
                }
            }
         */
        B b = new B();
    }
}

class B {
    static {
        System.out.println("B 静态代码块被执行");
        num = 300;
    }

    static int num = 100;

    public B() {
        System.out.println("B 构造器被执行");
    }
}