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.