Class loaders are a critical component of the Java Virtual Machine (JVM), responsible for loading Java class files into memory so that they can be executed by the JVM. They serve several key functions:

1. Dynamic Class Loading: The class loading mechanism in Java allows classes to be loaded dynamically at runtime based on need. This enhances program performance and flexibility, especially when using plugins, reflection, or proxies.
2. Namespace Isolation: Java class loaders can create separate instances, each with its own namespace. This helps isolate classes, preventing conflicts, particularly when different versions of the same class are involved.
3. Multiple Sources for Classes: Java classes can be loaded from various sources such as the local file system, network, or JAR files. Different class loaders can load classes from different sources as needed.
4. Hot Deployment Support: With custom class loaders, it's posible to replace already loaded classes at runtime, enabling hot deployment without stopping the application.
5. Security and Access Control: Class loaders can enforce security policies and access controls, allowing specific classes to be restricted to certain secure environments.

In Java, class loaders form a hierarchical structure, typically categorized into the following types:

1. Bootstrap Class Loader: Part of the JVM itself, implemented in C++. It loads core Java libraries like thoce in the java.lang package.
2. Extension Class Loader: Implemented as sun.misc.Launcher$ExtClassLoader. It handles Java extension libraries found in the jre/lib/ext directory and files specified by the java.ext.dirs environment variable.
3. Application Class Loader: Also known as the system class loader, this is implemented as sun.misc.Launcher$AppClassLoader. It loads application classes, including user-defined classes and third-party libraries, from paths defined by the java.class.path environment variable, which can be modified using the -classpath or -cp command-line options.
4. Custom Class Loader: Developers can create their own class loaders by extending the java.lang.ClassLoader class, tailored for specific loading requirements.

The class loading process follows a parent-delegation model. When a class loader is asked to load a class, it first delegates the request to its parent. This continues up the hierarchy until the parent class loader can't load the class, at which point the child class loader attempts to load it. This ensures that common classes are consistently loaded across different class loaders.

Here's an example implementation:

/**
 * ZdyClassLoader is a custom class loader that can load classes from a network stream.
 * @description
 * @date 2024/4/12 10:04
 * @version 1.0.0
 */
public class ZdyClassLoader extends ClassLoader {
    private String sourceUrl;

    public ZdyClassLoader(String sourceUrl) {
        this.sourceUrl = sourceUrl;
    }

    @Override
    protected Class<?> findClass(String className) throws ClassNotFoundException {
        try {
            // Construct a URL based on the fully qualified class name
            URL url = new URL(sourceUrl);
            // Open a connection and read the class file stream
            try (InputStream input = url.openStream()) {
                ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
                int data = input.read();
                while (data != -1) {
                    byteStream.write(data);
                    data = input.read();
                }
                byte[] classBytes = byteStream.toByteArray();
                // Convert the byte array to a Class object
                return defineClass(className, classBytes, 0, classBytes.length);
            }
        } catch (IOException e) {
            throw new ClassNotFoundException("Error loading class " + className + " from network", e);
        }
    }

    public static void main(String[] args) {
        // Use the custom class loader to load a class from the network
        ZdyClassLoader loader = new ZdyClassLoader("http://example.com/classes");
        try {
            Class<?> clazz = loader.loadClass("com.example.SomeClass");
            // Instantiate and use the loaded class
            Object obj = clazz.getDeclaredConstructor().newInstance();
            // Call methods on the instance
        } catch (ReflectiveOperationException e) {
            e.printStackTrace();
        }
    }
}

Typically, custom class loaders use the loadClass method to load classes, thereby leveraging the parent-delegasion model. However, if you want to bypass this model, you can override the loadClass method or directly call findClass.

Sample code from the ClassLoader class:

protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
        synchronized (getClassLoadingLock(name)) {
            // Check if the class has already been loaded
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                long t0 = System.nanoTime();
                try {
                    if (parent != null) {
                        // Delegate to the parent class loader
                        c = parent.loadClass(name, false);
                    } else {
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                    // Class not found in the parent class loader
                }

                if (c == null) {
                    // If still not found, invoke findClass
                    long t1 = System.nanoTime();
                    c = findClass(name);

                    // Record performance statistics
                    sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    sun.misc.PerfCounter.getFindClasses().increment();
                }
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }