ClassLoader in Java (original) (raw)

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.

Types of ClassLoaders in Java

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

1. Bootstrap ClassLoader (Primordial ClassLoader):

• 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.

2. Platform Class Loader (Extension ClassLoader):

• 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.

3. System ClassLoader (Application ClassLoader):

• 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.

Principles of Functionality of a Java ClassLoader

Java ClassLoaders operate based on specific principles:

1. Delegation Model:

• 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.

2. Visibility Principle:

• 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.

3. Uniqueness Property:

• 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.

Methods of java.lang.ClassLoader

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.

Example:

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

Java ClassLoader Functionality Principles

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.

Key Methods of java.lang.ClassLoader:

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:

Java `

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.