Tell us about class loaders and dynamic class loading…

ClassLoader is an object responsible for loading Java classes at runtime. The JVM does not know about class files until they are explicitly or implicitly requested. ClassLoader handles searching, reading, and defining the bytecode of a class, turning it into a Class object.

Main types of built-in ClassLoaders:

Bootstrap ClassLoader: Loads core Java classes from rt.jar (runtime library) and other core libraries. It is the ancestor of all other loaders. Written in C/C++.
Extension ClassLoader: Loads classes from the jre/lib/ext directory. It serves to extend the platform. It is a child of the Bootstrap ClassLoader.
System (Application) ClassLoader: Loads classes from the application's classpath. It is the default loader for user classes. It is a child of the Extension ClassLoader.

ClassLoaders work on a delegation principle: when a ClassLoader receives a request to load a class, it first delegates this request to its parent. If the parent cannot load the class, then the current ClassLoader attempts to load it itself.

Dynamic class loading in Java allows loading classes during program execution, not at startup. This is achieved using Class.forName() or by creating a custom ClassLoader.

Applications of dynamic loading:

Plugin architecture: Applications can load and execute code of "plugins" unknown in advance.
Lazy loading: Classes are loaded only when needed, saving resources.
Modifying behavior at runtime: Ability to load different implementations of interfaces or classes depending on conditions.

Example of dynamic loading using Class.forName():

// Dynamic loading and instantiation of a class
try {
    // Class name for dynamic loading
    String className = "com.example.MyDynamicClass";

    // Getting Class object by name
    Class<?> dynamicClass = Class.forName(className);

    // Creating an instance of the class (requires a no-argument constructor)
    Object instance = dynamicClass.getDeclaredConstructor().newInstance();

    // If the class implements a known interface
    if (instance instanceof MyInterface) {
        MyInterface myObject = (MyInterface) instance;
        myObject.doSomething();
    }

} catch (ClassNotFoundException e) {
    System.err.println("Class not found: " + e.getMessage());
} catch (InstantiationException | IllegalAccessException | NoSuchMethodException | java.lang.reflect.InvocationTargetException e) {
    e.printStackTrace();
}

// The class that might be loaded dynamically
// package com.example;
// public class MyDynamicClass implements MyInterface {
//     public MyDynamicClass() { ... }
//     @Override
//     public void doSomething() {
//         System.out.println("Doing something dynamically!");
//     }
// }

// The interface
// public interface MyInterface {
//     void doSomething();
// }

Creating a custom ClassLoader for more flexible loading:

// Example of a simple custom class loader
import java.io.*;

class CustomClassLoader extends ClassLoader {

    private String classDir;

    public CustomClassLoader(String classDir) {
        this.classDir = classDir;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        byte[] classData = loadClassFromFile(name); // Load bytecode from file

        if (classData == null) {
            throw new ClassNotFoundException("Class not found in directory: " + name);
        }

        // Define class from bytecode
        return defineClass(name, classData, 0, classData.length);
    }

    private byte[] loadClassFromFile(String name) {
        String fileName = classDir + File.separator + name.replace('.', File.separatorChar) + ".class";
        File file = new File(fileName);

        try (InputStream is = new FileInputStream(file);
             ByteArrayOutputStream os = new ByteArrayOutputStream()) {

            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = is.read(buffer)) != -1) {
                os.write(buffer, 0, bytesRead);
            }
            return os.toByteArray();

        } catch (IOException e) {
            return null; // File not found or read error
        }
    }
}

// How to use the custom ClassLoader
// public static void main(String[] args) {
//    String classesPath = "/path/to/your/custom/classes"; // Path to directory with .class files
//    CustomClassLoader customLoader = new CustomClassLoader(classesPath);
//
//    try {
//        String classNameToLoad = "com.yourcompany.YourCustomClass";
//        Class<?> customClass = customLoader.loadClass(classNameToLoad);
//        Object instance = customClass.getDeclaredConstructor().newInstance();
//        // Further work with the instance
//
//    } catch (ClassNotFoundException e) {
//        System.err.println("Custom class not found: " + e.getMessage());
//    } catch (InstantiationException | IllegalAccessException | NoSuchMethodException | java.lang.reflect.InvocationTargetException e) {
//        e.printStackTrace();
//    }
// }

It is important to understand that each ClassLoader defines its own namespace for classes. A class with the same full name loaded by different ClassLoaders is considered different classes. This property is used for application or component isolation.

Tell us about class loaders and dynamic class loading in Java.