JVM 类加载器有哪些？双亲委派机制的作用是什么？如何自定义类加载器？

ClassLoader loader = String.class.getClassLoader();
System.out.println(loader); // 输出 null，因为 String 是由引导类加载器加载的

ClassLoader extLoader = ClassLoader.getSystemClassLoader().getParent();
System.out.println(extLoader); // 输出 sun.misc.Launcher$ExtClassLoader

ClassLoader appLoader = ClassLoader.getSystemClassLoader();
System.out.println(appLoader); // 输出 sun.misc.Launcher$AppClassLoader

public abstract class ClassLoader {

    /*
     * 类加载器的父加载器
     */
    private final ClassLoader parent;

    /**
     * 根据类的全限定名加载类
     *
     * @param name 类名称
     * @return     加载的Class对象
     * @throws ClassNotFoundException 没有发现指定类异常
     */
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        // 调用loadClass方法加载类，其中设置resolve=false，表示不立即解析类
        return loadClass(name, false);
    }

    /**
     * 根据类的全限定名加载类
     *
     * @param name    类名称
     * @param resolve 是否解析这个类，true=解析，false=不解析
     * @return 加载的Class对象
     * @throws ClassNotFoundException 没有发现指定类异常
     */
    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
        synchronized (getClassLoadingLock(name)) {
            // 检查类是否已经被加载
            Class<?> c = findLoadedClass(name);
            // 如果没有加载过
            if (c == null) {
                // 如果有父类加载器，则委托给父加载器去加载
                // 如果没有父类加载器，则判断 Bootstrap 类加载器是否加载过
                if (parent != null) {
                    c = parent.loadClass(name, false);
                } else {
                    c = findBootstrapClassOrNull(name);
                }
                // 如果父类加载器都加载失败，则当前类加载器尝试自行加载
                if (c == null) {
                    c = findClass(name);
                }
            }
            // 据 resolve 参数决定是否解析类
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }

    /**
     * 查找并加载指定名称的类
     *
     * @param name 类名称
     * @return Class对象
     * @throws ClassNotFoundException 没有发现指定类异常
     */
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        //1. 根据传入的类名，到在特定目录下去寻找类文件，把字节码文件读入内存
        // ...
        //2. 调用 defineClass 将字节数组转成 Class 对象
        return defineClass(buf, off, len)；
    }

    /**
     * 将一个 byte[] 转换为 Class 类的实例
     *
     * @param name 类名称，如果不知道此名称，则该参数为 null
     * @param b    组成类数据的字节数组
     * @param off  类数据的起始偏移量
     * @param len  类数据的长度
     * @return Class对象
     * @throws ClassFormatError 类格式化异常
     */
    protected final Class<?> defineClass(byte[] b, int off, int len) throws ClassFormatError {
        ...
    }

}

import java.io.*;

public class MyClassLoader extends ClassLoader {
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        byte[] classData = loadClassData(name);
        if (classData == null) {
            throw new ClassNotFoundException();
        }
        return defineClass(name, classData, 0, classData.length);
    }

    private byte[] loadClassData(String name) {
        String fileName = name.replace('.', '/') + ".class";
        try (InputStream is = new FileInputStream(fileName);
             ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
            int buffer;
            while ((buffer = is.read()) != -1) {
                baos.write(buffer);
            }
            return baos.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }
}