Three Ways to Obtain a Class Object

#Introduction

In the previous chapter we learned that Reflection starts with the Class object, and the Class object holds metadata about a class. Now the question is: how do we obtain the Class object?

Java provides three standard ways:

1. ClassName.class
2. object.getClass()
3. Class.forName()

Every Java developer should know when to use each one.

#Overview

#Method 1 — Using .class

class Employee {
}

Class<Employee> cls = Employee.class;

Employee.class returns the Class object representing Employee.

How Does It Work?

During compilation, the compiler already knows Employee, so the expression refers directly to the corresponding Class object. No object creation is required.

Advantages

• Very simple
• Fast
• Type-safe (Class<Employee>, not Class<?>)
• No object required

Disadvantage

The class name must be known during compilation. Employee.class works, but this is impossible:

String className = "Employee";
className.class;   // ❌ does not compile

Interview Questions on .class

#Method 2 — Using getClass()

class Employee {
}

Employee emp = new Employee();
Class<?> cls = emp.getClass();

Returns the runtime class of the object.

Internal Working

Every Java object internally stores a reference to its class. When we write emp.getClass(), the JVM simply returns that stored reference.

The Object Must Already Exist

Without an object, we cannot call getClass():

Employee.getClass();          // ❌ compilation error — getClass() is an instance method

Employee emp = new Employee();
emp.getClass();               // ✅ correct

Advantage — The Actual Runtime Type

Useful when we don't know the object's exact type:

Object obj = new Employee();
obj.getClass();   // Employee, not Object

It returns the actual runtime class.

Object obj = "Hello";
System.out.println(obj.getClass());

class java.lang.String

Object obj = 100;
System.out.println(obj.getClass());

class java.lang.Integer

…because of autoboxing.

#Method 3 — Using Class.forName()

The most important method in Reflection.

Class<?> cls = Class.forName("com.demo.Employee");

Notice the argument is a fully qualified class name — not just Employee, but com.demo.Employee.

What Does Class.forName() Do?

It asks the JVM: "Load this class if it is not already loaded, and return its Class object."

Why Frameworks Use It

Imagine Spring Boot. You write com.company.UserService. Spring knows that name only as a String, and later turns it into a class:

Class.forName(className);

Spring never writes new UserService() because it doesn't know your class at compile time.

Dynamic Class Loading

String className = "com.demo.Employee";
Class<?> cls = Class.forName(className);

Tomorrow className = "com.demo.Student" — no code changes required, only the string changes. This is called dynamic class loading.

ClassNotFoundException

Suppose Class.forName("ABC") is called but no ABC class exists. The JVM throws ClassNotFoundException (a checked exception), so:

try {
    Class.forName("ABC");
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}

#Difference Between All Three

#Which One Should We Use?

Real-World Example

Suppose application.properties contains:

service.class=com.demo.UserService

Java code:

String className = properties.getProperty("service.class");
Class<?> cls = Class.forName(className);

Now the application is configurable without changing source code.

#Key Points to Remember

• Reflection always begins by obtaining a Class object.
• Java provides three ways to obtain it.
• .class is compile-time and type-safe.
• getClass() returns the runtime class of an existing object.
• Class.forName() dynamically loads a class using its fully qualified name.
• Frameworks use Class.forName()-style loading because class names often become available only at runtime.