类的生命周期
加载、连接、初始化、使用和卸载
加载，查找并加载类的二进制数据，加载指的是将类的class文件读入到内存，并为之创建一个java.lang.Class对象，也就是说，当程序中使用任何类时，系统都会为之建立一个java.lang.Class对象。
连接，当类被加载之后，系统为之生成一个对应的Class对象，接着将会进入连接阶段，连接阶段负责把类的二进制数据合并到JRE中。
连接又包含三块内容：验证、准备、初始化。
1）验证，验证的目的在于确保Class文件的字节流中包含信息符合当前虚拟机要求，不会危害虚拟机自身安全。其主要包括四种验证，文件格式验证，元数据验证，字节码验证，符号引用验证。
2）准备，为类的静态变量分配内存，并将其初始化为默认值；
3）解析，把类中的符号引用转换为直接引用。
初始化，为类的静态变量赋予正确的初始值。
使用，new出对象程序中使用
卸载，执行垃圾回收。
类加载时机
1 创建类的实例，也就是new一个对象
2 访问某个类或接口的静态变量，或者对该静态变量赋值
3 调用类的静态方法
4 反射（Class.forName("com.lyj.load")）
5 初始化一个类的子类（会首先初始化子类的父类）
6 JVM启动时标明的启动类，即文件名和类名相同的那个类
除此之外，下面几种情形需要特别指出：
对于一个final类型的静态变量，如果该变量的值在编译时就可以确定下来，那么这个变量相当于“宏变量”。Java编译器会在编译时直接把这个变量出现的地方替换成它的值，因此即使程序使用该静态变量，也不会导致该类的初始化。反之，如果final类型的静态Field的值不能在编译时确定下来，则必须等到运行时才可以确定该变量的值，如果通过该类来访问它的静态变量，则会导致该类被初始化.
ClassLoader 的分类及加载顺序
ClassLoader分为4种：Jvm根类加载器（BootstarpClassLoader），Jvm扩展类加载器（extClassLoader），系统类加载器（SystemClassLoader），自定义类加载器（AppClassLoader）
JVM预定义有三种类加载器，当一个 JVM启动的时候，Java开始使用如下三种类加载器：
1)根类加载器（bootstrap class loader）:这个类加载器负责将lib目录下的类库加载到虚拟机内存中,用来加载java的核心库,此类加载器并不继承于java.lang.ClassLoader,不能被java程序直接调用,代码是使用C++编写的.是虚拟机自身的一部分。
2)扩展类加载器（extensions class loader）：它负责加载JRE的扩展目录，lib/ext或者由java.ext.dirs系统属性指定的目录中的JAR包的类。由Java语言实现，父类加载器为null。
3)系统类加载器（system class loader）：被称为系统（也称为应用）类加载器，它负责在JVM启动时加载来自Java命令的-classpath选项、java.class.path系统属性，或者CLASSPATH换将变量所指定的JAR包和类路径。程序可以通过ClassLoader的静态方法getSystemClassLoader()来获取系统类加载器。如果没有特别指定，则用户自定义的类加载器都以此类加载器作为父加载器。由Java语言实现，父类加载器为ExtClassLoader。
类加载器加载Class大致要经过如下8个步骤：
1检测此Class是否载入过，即在缓冲区中是否有此Class，如果有直接进入第8步，否则进入第2步。
2 如果没有父类加载器，则要么Parent是根类加载器，要么本身就是根类加载器，则跳到第4步，如果父类加载器存在，则进入第3步。
3 请求使用父类加载器去载入目标类，如果载入成功则跳至第8步，否则接着执行第5步。
4 请求使用根类加载器去载入目标类，如果载入成功则跳至第8步，否则跳至第7步。
5 当前类加载器尝试寻找Class文件，如果找到则执行第6步，如果找不到则执行第7步。
6 从文件中载入Class，成功后跳至第8步。
7 抛出ClassNotFountException异常。
8 返回对应的java.lang.Class对象
缓冲区是否有class ---->无则请求父类加载器 ---->无则请求根类加载器 ---->无则请问当前类加载器
----------------------------------------------------------------------------------------------------------------------------
ClassLoader加载顺序：
=>Jvm类加载器加载JAVA_HOME/lib下的所有jar文件
=>Jvm扩展类加载器加载JAVA_HOME/lib/ext下的所有jar文件
=>系统类加载器加载指定classpath下所有jar文件
=>自定义类加载器加载继承官方提供的ClassLoader类的自定义实现加载器class文件。
----------------------------------------------------------------------------------------------------------------------------
类加载的顺序是
加载->链接（验证+准备+解析）->初始化（使用前的准备）->使用->卸载
Jvm会在启动的时候去加载系统所必须的JAVA_HOME/lib下的所有jar文件，
Jvm对于第三方类会才用懒加载的方式，即：用到的时候再进行加载，加载完成会放入缓存，以便后续使用。
类加载机制
全盘负责：所谓全盘负责，就是当一个类加载器负责加载某个Class时，该Class所依赖和引用其他Class也将由该类加载器负责载入，除非显示使用另外一个类加载器来载入。
双亲委派：所谓的双亲委派，则是先让父类加载器试图加载该Class，只有在父类加载器无法加载该类时才尝试从自己的类路径中加载该类。通俗的讲，就是某个特定的类加载器在接到加载类的请求时，首先将加载任务委托给父加载器，依次递归，如果父加载器可以完成类加载任务，就成功返回；只有父加载器无法完成此加载任务时，才自己去加载。
双亲委派机制的优势：采用双亲委派模式的是好处是Java类随着它的类加载器一起具备了一种带有优先级的层次关系，通过这种层级关可以避免类的重复加载，当父亲已经加载了该类时，就没有必要子ClassLoader再加载一次。其次是考虑到安全因素，java核心api中定义类型不会被随意替换，假设通过网络传递一个名为java.lang.Integer的类，通过双亲委托模式传递到启动类加载器，而启动类加载器在核心Java API发现这个名字的类，发现该类已被加载，并不会重新加载网络传递的过来的java.lang.Integer，而直接返回已加载过的Integer.class，这样便可以防止核心API库被随意篡改。
缓存机制：缓存机制将会保证所有加载过的Class都会被缓存，当程序中需要使用某个Class时，类加载器先从缓存区中搜寻该Class，只有当缓存区中不存在该Class对象时，系统才会读取该类对应的二进制数据，并将其转换成Class对象，存入缓冲区中。这就是为很么修改了Class后，必须重新启动JVM，程序所做的修改才会生效的原因。
双亲委任模型时如何实现的
jdk中classloader中loadclass方法的实现如下所示：
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException { synchronized (getClassLoadingLock(name)) { // First, check if the class has already been loaded //查找.class是否被加载过 Class<?> c = findLoadedClass(name); if (c == null) { long t0 = System.nanoTime(); try { //查看父加载器有没有加载过 if (parent != null) { c = parent.loadClass(name, false); } else { //还没找到的话查找根加载器，这里就是双亲委派模型的实现 c = findBootstrapClassOrNull(name); } } catch (ClassNotFoundException e) { // ClassNotFoundException thrown if class not found // from the non-null parent class loader } if (c == null) { // If still not found, then invoke findClass in order // to find the class. //找到根加载器依然为空，只能子加载器自己加载了 long t1 = System.nanoTime(); c = findClass(name); // this is the defining class loader; record the stats sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0); sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1); sun.misc.PerfCounter.getFindClasses().increment(); } } // 解析class文件，就是将符号引用替换为直接引用的过程 if (resolve) { resolveClass(c); } return c; } }
在这其中，涉及到一个findclass方法，查看源码后结果如下所示：
protected Class<?> findClass(String name) throws ClassNotFoundException { throw new ClassNotFoundException(name); }
这只是一个空方法，返回内容为class，方法其中没有任何内容，只抛出了个异常，说明这个方法需要开发者自己去实现。
根据源码可以知道，如果自定义的方法不想违背双亲委派模型，则只需要重写findclass方法即可，如果想违背双亲委派模型，则还需要重写loadclass方法。
如何打破双亲委派机制
打破双亲委派机制则不仅要继承ClassLoader类，还要重写loadClass和findClass方法。
定义Test类
public class Test { public Test(){ System.out.println(this.getClass().getClassLoader().toString()); } }
重新定义一个继承ClassLoader的TestClassLoaderN类，这个类与前面的TestClassLoader类很相似，但它除了重写findClass方法外还重写了loadClass方法，默认的loadClass方法是实现了双亲委派机制的逻辑，即会先让父类加载器加载，当无法加载时才由自己加载。这里为了破坏双亲委派机制必须重写loadClass方法，即这里先尝试交由System类加载器加载，加载失败才会由自己加载。它并没有优先交给父类加载器，这就打破了双亲委派机制。
public class TestClassLoaderN extends ClassLoader { private String name; public TestClassLoaderN(ClassLoader parent, String name) { super(parent); this.name = name; } @Override public String toString() { return this.name; } @Override public Class<?> loadClass(String name) throws ClassNotFoundException { Class<?> clazz = null; ClassLoader system = getSystemClassLoader(); try { clazz = system.loadClass(name); } catch (Exception e) { // ignore } if (clazz != null) return clazz; clazz = findClass(name); return clazz; } @Override public Class<?> findClass(String name) { InputStream is = null; byte[] data = null; ByteArrayOutputStream baos = new ByteArrayOutputStream(); try { is = new FileInputStream(new File("d:/Test.class")); int c = 0; while (-1 != (c = is.read())) { baos.write(c); } data = baos.toByteArray(); } catch (Exception e) { e.printStackTrace(); } finally { try { is.close(); baos.close(); } catch (IOException e) { e.printStackTrace(); } } return this.defineClass(name, data, 0, data.length); } public static void main(String[] args) { TestClassLoaderN loader = new TestClassLoaderN( TestClassLoaderN.class.getClassLoader(), "TestLoaderN"); Class clazz; try { clazz = loader.loadClass("test.classloader.Test"); Object object = clazz.newInstance(); } catch (Exception e) { e.printStackTrace(); } } }
面试题：
在自己的代码中，可以创建一个java.lang.String对象吗？如果可以，这个对象是否可以被类加载器加载？
可以创建，但是不能被加载到。
因为，双亲委派模式会保证父类加载器先加载类，就是BootStrap（启动类）加载器加载jdk里面的java.lang.String类，而自定义的java.lang.String类永远不会被加载到
转载：https://www.cnblogs.com/TravisGrady/p/10383119.html
https://blog.csdn.net/m0_38075425/article/details/81627349