Class Loading and Class.forName() Internals

#Introduction

In the previous chapter we learned that Class.forName("com.demo.Employee") returns the Class object. But interviewers often ask:

#What is Class Loading?

A .class file is just a file stored on disk:

Until now, the JVM doesn't know anything about this class. Only when the program needs the class does the JVM load it into memory. This process is called class loading.

Definition: class loading is the process of reading a .class file from disk (or another source), bringing its bytecode into the JVM, and preparing it for execution.

Real-Life Analogy

A movie stored on your laptop is just a file until you click Play — then the media player loads it into RAM and it can be played. Similarly, Employee.class is only a file; the JVM must load it into memory before it can be used.

#When Does Class Loading Happen?

Many beginners think the JVM loads every class at startup. ❌ Wrong. Java uses lazy loading: the JVM loads a class only when it is needed.

public class Demo {
    public static void main(String[] args) {
        System.out.println("Hello");
    }
}

If the project has 500 classes, will the JVM load all 500? No — only the required classes are loaded.

Employee emp = new Employee();          // JVM needs Employee → Employee.class is loaded

Class.forName("com.demo.Employee");     // again, Employee.class is loaded

#Who Loads Classes?

A class loader — a JVM component responsible for locating, loading and defining classes in memory. Without a class loader, Java programs cannot execute.

#Types of Class Loaders

Java provides three built-in class loaders:

Bootstrap Class Loader

The parent of all class loaders. Loads core Java classes, e.g. java.lang.String, java.lang.Object, java.util.ArrayList, java.util.HashMap, java.lang.Integer. Without it, Java itself cannot run.

Platform Class Loader

Loads Java platform modules such as java.sql, java.xml and java.naming — standard Java libraries that aren't part of the minimal core runtime.

Application Class Loader

The one developers interact with most. It loads your project classes, third-party JARs, Maven dependencies, Spring Boot classes and Hibernate classes — e.g. com.demo.Employee, com.demo.Student, com.company.UserService.

This hierarchy follows the parent delegation model.

#Parent Delegation Model

Suppose the JVM needs java.lang.String. Will the Application ClassLoader load it? No — it first asks its parent.

Now suppose com.demo.Employee:

Why Parent Delegation?

Suppose a developer creates:

package java.lang;

public class String {
}

Without parent delegation, the JVM might load the fake String instead of the real one, which would break Java. Parent delegation ensures trusted core classes are loaded first.

#Class Loading Phases

When a class is loaded, the JVM performs three major phases. This sequence is guaranteed by the JVM.

Phase 1 — Loading

The JVM finds the .class file, reads its bytecode and creates a Class object.

Phase 2 — Linking

Linking has three steps:

Verification — the JVM checks whether the bytecode is valid (no invalid bytecode, illegal instructions or corrupted class file). If verification fails, the class is rejected (VerifyError).

Preparation — static variables receive default values:

class Employee {
    static int x = 100;
}

During preparation x = 0. Only default values are assigned.

Resolution — symbolic references (names like Employee in the constant pool) are replaced with direct references to the actual runtime structures. The JVM may do this lazily, the first time each reference is used.

Phase 3 — Initialization

Now the JVM executes static variable assignments and static blocks:

class Employee {
    static {
        System.out.println("Employee Loaded");
    }
}

Employee Loaded

#What Does Class.forName() Do?

Class.forName("com.demo.Employee");

Internally:

Example

class Employee {
    static {
        System.out.println("Static Block");
    }
}

public class Demo {
    public static void main(String[] args) throws Exception {
        Class.forName("Employee");
    }
}

Static Block

#Loading vs Initialization

Many interviewers ask this difference.

#Can We Load Without Initialization?

Yes. Java provides another API:

ClassLoader.loadClass()

It loads the class but does not initialize it. There is also an overloaded version of Class.forName():

Class.forName(
        "com.demo.Employee",
        false,
        Demo.class.getClassLoader()
);

Here false means load the class but don't initialize it yet. Initialization happens later, when the JVM actively uses the class.

#Class.forName() vs ClassLoader.loadClass()

Example

class Demo {
    static {
        System.out.println("Loaded");
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        Class.forName("Demo");                                // prints "Loaded"
        // Main.class.getClassLoader().loadClass("Demo");     // prints nothing
    }
}

With Class.forName("Demo") the output is Loaded. With loadClass("Demo") there is no output, because the class is loaded but not initialized.

#Real-World Usage

JDBC Drivers (Older Style)

Developers used to write:

Class.forName("com.mysql.jdbc.Driver");

This loaded the driver class, executed its static block, and the static block registered the driver with DriverManager.

Spring Framework

Spring scans @Component, @Service and @Repository classes. It loads classes, reads metadata, creates beans and performs dependency injection — Reflection depends on classes being loaded.

Hibernate

Hibernate loads entity classes, reads annotations, creates metadata and maps classes to database tables.

#Key Points to Remember

• Java uses lazy class loading — classes are loaded only when required.
• Class loading is handled by class loaders: Bootstrap → Platform → Application.
• Parent delegation protects core Java classes.
• Class loading has three phases: Loading, Linking (verify, prepare, resolve), Initialization.
• Class.forName() initializes the class by default.
• Static blocks execute during the Initialization phase.