Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/java/classloader-in-java/ below:

ClassLoader in Java - GeeksforGeeks

Last Updated : 11 Jul, 2025

The Java ClassLoader is an integral part of the Java Runtime Environment (JRE) that dynamically loads Java classes into the Java Virtual Machine (JVM). The Java run time system does not need to know about files and file systems because of classloaders. Java classes aren’t loaded into memory all at once, but when required by an application. At this point, the Java ClassLoader is called by the JRE, and these ClassLoaders load classes into memory dynamically.

ClassLoaders play a crucial role in Java's ability to dynamically load classes into memory as needed, enabling flexibility and efficiency in Java applications.

Java's ClassLoaders are categorized into different types, each responsible for loading classes from specific locations:

• The Bootstrap ClassLoader is a machine code responsible for initiating the JVM's operations.
• In Java versions up to 8, it loaded core Java files from rt.jar. However, starting from Java 9, it loads core Java files from the Java Runtime Image (JRT).
• Bootstrap ClassLoader operates independently without any parent ClassLoaders.

• In Java versions before Java 9, there was an Extension ClassLoader, but from Java 9 onwards, it's referred to as the Platform Class Loader.
• It loads platform-specific extensions from the JDK's module system.
• Platform Class Loader loads files from the Java runtime image or from any other module specified by the system property java.platform or --module-path.

• Also known as the Application ClassLoader, it loads classes from the application's classpath.
• It is a child of the Platform Class Loader.
• Classes are loaded from directories specified by the environment variable CLASSPATH, the -classpath or -cp command-line option.

Java ClassLoaders operate based on specific principles:

• ClassLoaders follow a delegation hierarchy algorithm.
• When the JVM encounters a class, it checks if it's already loaded. If not, it delegates the loading process through a chain of ClassLoaders.
• The delegation hierarchy starts from the Application ClassLoader, then moves to the Platform Class Loader, and finally to the Bootstrap ClassLoader.
• Each ClassLoader in the hierarchy searches for the class in its defined locations and delegates the search if necessary.

• Classes loaded by parent ClassLoaders are visible to child ClassLoaders, but not vice versa.
• This ensures encapsulation and prevents conflicts between classes loaded by different ClassLoaders.

• ClassLoaders ensure that classes are loaded only once to maintain uniqueness.
• If a parent ClassLoader cannot find a class, only then the current instance attempts to load it.

Several methods in java.lang.ClassLoader facilitate the loading of classes:

• loadClass(String name, boolean resolve): Loads classes referenced by the JVM, resolving them if necessary.
• defineClass(): Defines a byte array as an instance of a class. Throws ClassFormatError if the class is invalid.
• findClass(String name): Finds a specified class without loading it.
• findLoadedClass(String name): Verifies if the class is already loaded.
• Class.forName(String name, boolean initialize, ClassLoader loader): Loads and initializes a class, allowing the specification of a ClassLoader. If the ClassLoader parameter is null, the Bootstrap ClassLoader is used by default.

// Code executed before class loading
Class<?> clazz = ClassLoader.getSystemClassLoader().loadClass("com.example.MyClass");

Principles of functionality are the set of rules or features on which a Java ClassLoader works. There are three principles of functionality, they are:

1. Delegation Model: The Java Virtual Machine and the Java ClassLoader use an algorithm called the Delegation Hierarchy Algorithm to Load the classes into the Java file. The ClassLoader works based on a set of operations given by the delegation model. They are:
   • ClassLoader always follows the Delegation Hierarchy Principle.
   • Whenever JVM comes across a class, it checks whether that class is already loaded or not.
   • If the Class is already loaded in the method area then the JVM proceeds with execution.
   • If the class is not present in the method area then the JVM asks the Java ClassLoader Sub-System to load that particular class, then ClassLoader sub-system hands over the control to Application ClassLoader.
   • Application ClassLoader then delegates the request to Extension ClassLoader and the Extension ClassLoader in turn delegates the request to Bootstrap ClassLoader.
   • Bootstrap ClassLoader will search in the Bootstrap classpath(JDK/JRE/LIB). If the class is available then it is loaded, if not the request is delegated to Extension ClassLoader.
   • Extension ClassLoader searches for the class in the Extension Classpath(JDK/JRE/LIB/EXT). If the class is available then it is loaded, if not the request is delegated to the Application ClassLoader.
   • Application ClassLoader searches for the class in the Application Classpath. If the class is available then it is loaded, if not then a ClassNotFoundException exception is generated.
2. Visibility Principle: The Visibility Principle states that a class loaded by a parent ClassLoader is visible to the child ClassLoaders but a class loaded by a child ClassLoader is not visible to the parent ClassLoaders. Suppose a class GEEKS.class has been loaded by the Extension ClassLoader, then that class is only visible to the Extension ClassLoader and Application ClassLoader but not to the Bootstrap ClassLoader. If that class is again tried to load using Bootstrap ClassLoader it gives an exception java.lang.ClassNotFoundException.
3. Uniqueness Property: The Uniqueness Property ensures that the classes are unique and there is no repetition of classes. This also ensures that the classes loaded by parent classloaders are not loaded by the child classloaders. If the parent class loader isn’t able to find the class, only then the current instance would attempt to do so itself.

After the JVM requests for the class, a few steps are to be followed in order to load a class. The Classes are loaded as per the delegation model but there are a few important Methods or Functions that play a vital role in loading a Class.

1. loadClass(String name, boolean resolve): This method is used to load the classes which are referenced by the JVM. It takes the name of the class as a parameter. This is of type loadClass(String, boolean).
2. defineClass(): The defineClass() method is a final method and cannot be overridden. This method is used to define a array of bytes as an instance of class. If the class is invalid then it throws ClassFormatError.
3. findClass(String name): This method is used to find a specified class. This method only finds but doesn't load the class.
4. findLoadedClass(String name): This method is used to verify whether the Class referenced by the JVM was previously loaded or not.
5. Class.forName(String name, boolean initialize, ClassLoader loader): This method is used to load the class as well as initialize the class. This method also gives the option to choose any one of the ClassLoaders. If the ClassLoader parameter is NULL then Bootstrap ClassLoader is used.

Example: The following code is executed before a class is loaded: 

protected synchronized Class<?>
loadClass(String name, boolean resolve)
    throws ClassNotFoundException
{
    Class c = findLoadedClass(name);
    try {
        if (c == NULL) {
            if (parent != NULL) {
                c = parent.loadClass(name, false);
            }
            else {
                c = findBootstrapClass0(name);
            }
        }
        catch (ClassNotFoundException e)
        {
            System.out.println(e);
        }
    }
}

Note: If a class has already been loaded, it returns it. Otherwise, it delegates the search for the new class to the parent class loader. If the parent class loader doesn't find the class, loadClass() calls the method findClass() to find and load the class. The findClass() method searches for the class in the current ClassLoader if the class wasn't found by the parent ClassLoader.

This article accurately reflects the updated understanding of Java ClassLoaders, including changes introduced from Java 9 onwards.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4