Reflection API

Java Reflection API is a powerful feature that allows programs to inspect and manipulate classes, methods, fields, and constructors at runtime. It is widely used in modern frameworks and tools to enable dynamic behavior.

What is Reflection API?

Reflection API in Java allows a program to inspect and manipulate classes, methods, fields, and constructors at runtime.

In simple words: It lets your program look inside itself and work dynamically, even if details are not known at compile time.

Why Reflection is Important

Reflection is widely used in real-world applications:

Spring Framework → Dependency Injection
Hibernate → Database mapping
JUnit → Running test cases
Jackson/Gson → JSON conversion

? It helps developers build flexible, reusable, and dynamic systems, which are very important in modern Java development.

Key Components of Reflection API

Java provides the java.lang.reflect package, which contains the core classes used in Reflection. These classes help you inspect and work with different parts of a program at runtime.

Main Classes:

Class → Represents a class and provides information like class name, methods, fields, and constructors
Field → Represents variables (fields) of a class and allows you to access or modify their values
Method → Represents methods of a class and allows you to invoke them dynamically at runtime
Constructor → Represents constructors and allows you to create objects dynamically

Step-by-Step Tutorial

Step 1: Accessing Classes

Reflection starts by getting the Class object, which represents the structure of a class at runtime.

class Person {}

public class Test {
    public static void main(String[] args) {
        Class<?> cls = Person.class;
        System.out.println(cls.getName());
    }
}

Explanation

Person.class → Gets the Class object of the Person class
Class<?> → Represents any type of class (generic type)
getName() → Returns the full class name

Output

Person

Step 2: Accessing Fields

In this step, Reflection is used to access and read a private field from a class. Normally, private fields cannot be accessed directly, but Reflection allows you to bypass this restriction.

import java.lang.reflect.Field;

class Person {
    private String name = "Amit";
}

public class Test {
    public static void main(String[] args) throws Exception {

        Class<?> cls = Person.class;
        Object obj = cls.getDeclaredConstructor().newInstance();

        Field field = cls.getDeclaredField("name");
        field.setAccessible(true);

        System.out.println(field.get(obj));
    }
}

Explanation

getDeclaredField("name") → Accesses the private field name from the class
setAccessible(true) → Bypasses access control to allow access to private fields
field.get(obj) → Retrieves the value of the field from the object

Output

Amit

Step 3: Accessing Methods

In this step, Reflection is used to access and execute a method dynamically at runtime. This means you can call methods without directly using them in your code.

import java.lang.reflect.Method;

class Person {
    public void greet() {
        System.out.println("Hello!");
    }
}

public class Test {
    public static void main(String[] args) throws Exception {

        Class<?> cls = Person.class;
        Object obj = cls.getDeclaredConstructor().newInstance();

        Method method = cls.getMethod("greet");
        method.invoke(obj);
    }
}

Explanation

getMethod("greet") → Gets the public method greet from the class
invoke(obj) → Executes the method on the given object

Output

Hello!

Step 4: Dynamic Object Creation

In this step, Reflection is used to load a class and create its object dynamically at runtime. This is useful when the class name is not known at compile time.

class Person {}

public class Test {
    public static void main(String[] args) throws Exception {

        Class<?> cls = Class.forName("Person");
        Object obj = cls.getDeclaredConstructor().newInstance();

        System.out.println(obj.getClass().getName());
    }
}

Explanation

Class.forName("Person") → Loads the Person class at runtime using its name
getDeclaredConstructor().newInstance() → Creates a new object dynamically
obj.getClass().getName() → Gets the class name of the created object

Output

Person

Performance Considerations

Reflection is a powerful feature, but it is generally slower than normal Java code.

Why Reflection is Slower?

Works at runtime instead of compile-time
JVM cannot optimize reflection calls effectively
Involves additional processing like method lookup and access checks

Tips to Use Reflection Efficiently

Avoid using reflection inside loops or performance-critical code
Cache methods and fields if they are used multiple times
Prefer normal Java code when performance is important

? Reflection should be used carefully — it is best for flexibility, not for high-performance operations.

Security Concerns

Reflection can break Java’s built-in security and access control rules if not used carefully.

Risks

Access private data
Bypass encapsulation
Modify sensitive fields

Example

field.setAccessible(true);

? This allows access to private variables, which are normally restricted.

Best Practice

Use reflection only when required
Avoid using it in security-sensitive systems

Common Mistakes to Avoid

Using reflection everywhere unnecessarily
Ignoring performance impact
Not handling exceptions properly
Hardcoding class names
Misusing setAccessible(true)

Best Practices

Use reflection mainly in frameworks and advanced use cases
Cache reflection objects to improve performance
Avoid using reflection in performance-critical applications
Combine reflection with annotations for better design
Keep the code simple, clean, and readable

Conclusion

Reflection API is a powerful feature in Java that enables runtime inspection and control of classes, methods, fields, and constructors.

It is widely used in major frameworks like Spring, Hibernate, and testing tools.
It supports dynamic object creation and method execution, making applications more flexible.
However, it comes with performance and security trade-offs that developers must consider.