Reflection API

Reflection is Java's ability to examine and manipulate classes, fields, methods, and constructors at runtime — even ones the code calling reflection did not know about at compile time. The core classes live in java.lang.reflect, and the entry point is almost always a Class object obtained through obj.getClass(), SomeType.class, or Class.forName("fully.qualified.Name").

Reflection is what makes frameworks possible: dependency injection containers (Spring), serialization libraries (Jackson, Gson), testing frameworks (JUnit), and ORMs (Hibernate) all use reflection to discover annotated fields and methods on classes they were never compiled against, and to construct or populate objects generically. It is powerful, but it comes with real performance and safety trade-offs that advanced Java developers need to understand before reaching for it.

Why it matters

Spring creates your beans and injects their dependencies, JUnit finds your test methods, and Jackson and Hibernate fill in private fields, all without knowing your classes in advance. They do it through reflection. Understanding it removes the mystery from how frameworks work and from the stack traces they produce.

Inspecting a Class at Runtime

Once you have a Class object, you can query almost everything about the type: its fields with getDeclaredFields(), its methods with getDeclaredMethods(), its constructors with getDeclaredConstructors(), its superclass, its interfaces, and its annotations. The "declared" variants return members defined directly on that class (including private ones), while the non-"declared" variants (getFields(), getMethods()) return only public members, including inherited ones.

• Class.forName("com.example.Foo") — loads a class by name and returns its Class object.
• clazz.getDeclaredFields() / getDeclaredMethods() — all members declared on that class, regardless of access modifier.
• field.setAccessible(true) — bypasses Java's normal access checks so private members can be read or invoked.
• method.invoke(instance, args...) — calls a method reflectively, given a target object and its arguments.

Invoking Private Members

Normally, the compiler blocks access to private fields and methods from outside their class. Reflection can bypass this using setAccessible(true) on a Field, Method, or Constructor object, provided the JVM's module and security settings allow it. This is exactly how libraries like Gson populate private fields directly during deserialization, and how test frameworks call private helper methods to unit-test internal logic without exposing it publicly.

Performance and Safety Caveats

Reflective calls are noticeably slower than direct calls, because the JVM cannot fully optimize or inline a call it resolves by name at runtime, and each invocation goes through extra access checks and argument boxing. Reflection also weakens compile-time safety: typos in method or field names, or a mismatched argument type, only surface as a runtime NoSuchMethodException or IllegalArgumentException instead of a compile error. Since Java 9's module system, reflection into another module's internals can also be blocked entirely unless that module explicitly "opens" the package, which is a common source of runtime errors when upgrading legacy reflective code.

Example

import java.lang.reflect.*;
import java.util.*;

class Account {
    private String owner;
    private double balance;

    public Account(String owner, double balance) {
        this.owner = owner;
        this.balance = balance;
    }

    private double applyInterest(double rate) {
        return balance * rate;
    }
}

public class ReflectionDemo {
    public static void main(String[] args) throws Exception {
        Class<?> clazz = Class.forName("Account");

        Field[] fields = clazz.getDeclaredFields();
        Arrays.sort(fields, Comparator.comparing(Field::getName));
        System.out.println("Fields:");
        for (Field field : fields) {
            System.out.println("  " + field.getType().getSimpleName() + " " + field.getName());
        }

        System.out.println("Methods:");
        for (Method method : clazz.getDeclaredMethods()) {
            System.out.println("  " + method.getName());
        }

        Object account = clazz.getDeclaredConstructor(String.class, double.class)
                               .newInstance("Priya", 1000.0);

        Method applyInterest = clazz.getDeclaredMethod("applyInterest", double.class);
        applyInterest.setAccessible(true); // bypass private access for this demo
        Object result = applyInterest.invoke(account, 0.05);
        System.out.println("Interest: " + result);
    }
}

Fields:
  double balance
  String owner
Methods:
  applyInterest
Interest: 50.0

Exercise

Greeter has a private method. Using reflection, print how many methods the class declares, then make the private method accessible, invoke it on a new object with the argument Asha, and print the result.

Expected output: 1 then Hello, Asha

import java.lang.reflect.Method;

class Greeter {
    private String greet(String name) {
        return "Hello, " + name;
    }
}

public class CallPrivate {
    public static void main(String[] args) throws Exception {
        Class<?> type = Greeter.class;

        // TODO: print the number of declared methods
        // TODO: look up "greet", make it accessible, invoke it with "Asha" and print the result
    }
}

import java.lang.reflect.Method;

class Greeter {
    private String greet(String name) {
        return "Hello, " + name;
    }
}

public class CallPrivate {
    public static void main(String[] args) throws Exception {
        Class<?> type = Greeter.class;

        System.out.println(type.getDeclaredMethods().length); // 1

        Method method = type.getDeclaredMethod("greet", String.class);
        method.setAccessible(true);
        Object result = method.invoke(new Greeter(), "Asha");
        System.out.println(result); // Hello, Asha
    }
}

Quick quiz

Interview questions