All 15 Class Loading & Bytecode Verification questions
More in Class Loading & Bytecode Verification
How do you programmatically load a class by its fully-qualified name at runtime using Class.forName(), and what is a common real-world use case for this? What is the parent delegation model in Java class loading, and why is it important for security and consistency? What are the phases of class loading (loading, linking, initialization), and what specifically happens during each? What causes a ClassNotFoundException versus a NoClassDefFoundError, and how do you distinguish and diagnose each? How does the Java Platform Module System (JPMS, introduced in Java 9) change class loading and encapsulation compared to the traditional classpath model? What is the purpose of the -Xverify:none (or newer -noverify) JVM flag, and why is disabling bytecode verification generally discouraged? How does the ServiceLoader mechanism (java.util.ServiceLoader) provide a standardized way to discover and load implementations at runtime without hardcoding class names, and how does it relate to class loading? What is hot class reloading/redefinition (via Instrumentation.redefineClasses() or a JVM agent), and what are its practical limitations compared to a full class unload/reload? How would you implement a custom ClassLoader to load classes from a non-standard source, such as loading plugin JARs dynamically at runtime, and what challenges arise with class unloading? What is bytecode verification, and what specific categories of invalid or unsafe bytecode does the JVM's verifier reject before allowing a class to run?
Advertisement
Back to results for “JRE & Memory”
Java › Class Loading & Bytecode Verification

What is the role of the ClassLoader in the JVM, and what are the three built-in bootstrap/platform/application class loaders?

Beginner

Answer

A ClassLoader is responsible for locating and loading .class files (bytecode) into the JVM at runtime, converting them into Class objects usable by running code -- the JVM has a hierarchy of built-in loaders: the Bootstrap ClassLoader (written in native code, loads core JDK classes like java.lang.* from the JDK's own modules), the Platform ClassLoader (loads other JDK platform classes), and the Application/System ClassLoader (loads classes from the application's own classpath, the one typically used for your own application code).
public class Main {
    public static void main(String[] args) {
        ClassLoader loader = Main.class.getClassLoader();
        System.out.println(loader);  // typically: jdk.internal.loader.ClassLoaders$AppClassLoader

        ClassLoader stringLoader = String.class.getClassLoader();
        System.out.println(stringLoader);  // null, since String is loaded by the Bootstrap loader
    }
}
Real-world example A diagnostic logging statement printing which ClassLoader loaded a given class helps a team investigating a mysterious ClassCastException discover that two different ClassLoaders had independently loaded the same class name from different JARs, which the JVM treats as genuinely different types despite an identical class name.

Common follow-ups: Why does String.class.getClassLoader() return null instead of an actual ClassLoader instance?;What determines which of the three built-in class loaders is responsible for loading a particular class?

JVM JRE & Memory;Reflection API
All 15 Class Loading & Bytecode Verification questions