The Reflection API lets Java code examine and interact with its own structure at runtime — reading class names, listing methods and fields, reading annotations, and invoking methods — all without knowing those details at compile time. Every framework that inspects your classes without you telling it exactly what is in them uses reflection: Spring's component scanner, JUnit's test runner, Hibernate's entity mapper, Jackson's JSON serializer. None of them were compiled knowing the names of your fields or the signatures of your methods, yet they find and use them anyway. Reflection is the mechanism that makes all of that possible.

What Is the Reflection API?

Reflection is provided primarily through four classes in java.lang and java.lang.reflect:

java.lang.Class<T>
  The entry point for all reflection. Every loaded class, interface,
  enum, record, and array type has exactly one Class object in the JVM.
  From it, you can reach everything else.

java.lang.reflect.Method
  Represents one method declared on a class - its name, return type,
  parameter types, annotations, and modifiers. Can be invoked.

java.lang.reflect.Field
  Represents one field declared on a class - its name, type,
  annotations, and modifiers. Can be read or written.

java.lang.reflect.Constructor
  Represents one constructor - its parameter types, annotations, and
  modifiers. Can be used to create new instances.

Basic Overview - What Reflection Can and Cannot Do

GETTING A Class OBJECT (the starting point):

  Three ways to get one:

  ClassName.class       <- compile-time literal, type-safe, preferred
  object.getClass()     <- from a live object, returns the runtime class
  Class.forName("...")  <- from a fully-qualified string name at runtime

  Class.forName is the one frameworks use: Spring does not import YOUR
  classes at compile time - it finds them by scanning for class files
  and loading them by string name at startup

WHAT YOU CAN INSPECT (read-only, never needs setAccessible):

  class.getName()               <- "com.example.PaymentService"
  class.getSimpleName()         <- "PaymentService"
  class.getDeclaredMethods()    <- all methods declared in THIS class
  class.getMethods()            <- all PUBLIC methods incl. inherited
  class.getDeclaredFields()     <- all fields declared in THIS class
  class.getDeclaredConstructors() <- all constructors
  class.getAnnotation(X.class)  <- class-level annotation X if present
  method.getAnnotation(X.class) <- method-level annotation X if present
  class.getSuperclass()         <- direct superclass
  class.getInterfaces()         <- directly implemented interfaces

WHAT YOU CAN INVOKE/MODIFY (may need setAccessible(true) for private):

  method.invoke(instance, args) <- call a method on an object
  field.get(instance)           <- read a field's value
  field.set(instance, value)    <- write a field's value
  constructor.newInstance(args) <- create a new object

THE DECLARED vs NON-DECLARED SPLIT:
  Fresher view  : getDeclaredMethods() gives you what is IN this
                  class; getMethods() gives you what is CALLABLE
                  from outside (public, including inherited)
  Deeper view   : 'Declared' variants return private/protected/
                  package-private members too, but only from THIS
                  class - not inherited ones. Non-declared variants
                  return only public members but across the whole
                  inheritance hierarchy. For reflection-based
                  processors that need to reach private fields
                  (like ORM mappers reading entity fields),
                  getDeclaredFields() + setAccessible(true) is
                  the correct combination

setAccessible(true):
  Fresher view  : tells the JVM to bypass access modifiers for this
                  specific reflective operation. Required to read or
                  write private fields and call private methods.
  Deeper view   : in Java 9+ modules, setAccessible(true) may be
                  refused if the containing package is not OPEN to
                  the reflecting module. Frameworks configure module
                  opens in module-info.java or via command-line
                  --add-opens to make deep reflection work

Why the Reflection API Matters

The straightforward answer is that frameworks need it. But understanding WHY frameworks need it — rather than just accepting that they do — is what makes the API genuinely useful knowledge rather than trivia.

The fundamental constraint reflection works around is this: code must be compiled before it runs, but frameworks are compiled long before your application code exists. Spring's DI container was compiled years ago. It has no import for PaymentService. It cannot reference PaymentService.class in its own source code because PaymentService did not exist when Spring was written. Yet at startup, Spring finds PaymentService, reads its @Autowired constructors, reads its @Service annotation, and wires it into the application context — because reflection lets it discover and interact with classes using only their names and their annotations, with no compile-time dependency.

The same logic explains every other reflection use case:

Unit test runners. JUnit does not import your test classes. It scans for classes on the test classpath, loads them by name, finds methods annotated @Test via reflection, creates instances via the no-argument constructor, and invokes each test method — all at runtime, with no prior knowledge of what your tests are named.

JSON serialization. Jackson reads the field names and types of your DTO class at runtime to decide what JSON keys to produce. Your DTO class did not exist when Jackson was written. Reflection is how Jackson's ObjectMapper discovers firstName, lastName, and email in UserResponse without anyone telling it explicitly.

Custom validation frameworks. The entire AnnotationValidator from the custom annotations article works through reflection: it inspects field annotations on any class, without knowing the class's fields at compile time, and applies constraints generically.

How the Reflection API Works

Getting Class Objects

Java

Try it out

// File: ClassObjectDemo.java

import java.util.List;

public class ClassObjectDemo {

    static class PaymentGateway {
        private String gatewayName;
        public void process(String orderId) {}
    }

    public static void main(String[] args) throws ClassNotFoundException {

        System.out.println("=== Three ways to get a Class object ===");

        // 1. Compile-time class literal - type-safe, preferred when
        //    the class is known at compile time
        Class<PaymentGateway> byLiteral = PaymentGateway.class;
        System.out.println("By literal    : " + byLiteral.getName());

        // 2. From a live object - returns the RUNTIME class, which
        //    may be a subclass of the declared type
        PaymentGateway gateway = new PaymentGateway();
        Class<?> byInstance = gateway.getClass();
        System.out.println("By instance   : " + byInstance.getSimpleName());

        // 3. By fully-qualified string name - how frameworks find
        //    classes they were not compiled against
        Class<?> byName = Class.forName("java.util.ArrayList");
        System.out.println("By forName    : " + byName.getSimpleName());

        System.out.println();

        System.out.println("=== Class metadata ===");
        System.out.println("Name          : " + byLiteral.getName());
        System.out.println("Simple name   : " + byLiteral.getSimpleName());
        System.out.println("Package       : " + byLiteral.getPackageName());
        System.out.println("Superclass    : " + byLiteral.getSuperclass().getSimpleName());
        System.out.println("Is interface  : " + byLiteral.isInterface());
        System.out.println("Is enum       : " + byLiteral.isEnum());

        System.out.println();

        System.out.println("=== Generic class - inspecting List interface ===");
        Class<?> listClass = List.class;
        System.out.println("Is interface  : " + listClass.isInterface());
        System.out.println("Interfaces    : " + listClass.getInterfaces().length + " directly implemented");
    }
}

Output:
=== Three ways to get a Class object ===
By literal    : ClassObjectDemo$PaymentGateway
By instance   : PaymentGateway
By forName    : ArrayList

=== Class metadata ===
Name          : ClassObjectDemo$PaymentGateway
Simple name   : PaymentGateway
Package       : 
Superclass    : Object
Is interface  : false
Is enum       : false

=== Generic class - inspecting List interface ===
Is interface  : true
Interfaces    : 1 directly implemented

Inspecting Methods and Fields

Java

Try it out

// File: InspectionDemo.java

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class InspectionDemo {

    static class OrderService {
        private final String serviceId = "ORDER-SVC-01";
        private int processedCount;
        public String status = "ACTIVE";

        public void processOrder(String orderId, double amount) {}
        private void validateOrder(String orderId) {}
        protected boolean checkInventory(String productId) { return true; }
        public static void resetCounters() {}
    }

    public static void main(String[] args) {
        Class<OrderService> clazz = OrderService.class;

        System.out.println("=== getDeclaredMethods() - ALL methods in THIS class ===");
        for (Method method : clazz.getDeclaredMethods()) {
            String access = Modifier.toString(method.getModifiers());
            System.out.printf("  %-12s %-20s params=%d%n",
                access, method.getName(), method.getParameterCount());
        }

        System.out.println();

        System.out.println("=== getMethods() - only PUBLIC methods, including inherited ===");
        int publicCount = 0;
        for (Method method : clazz.getMethods()) {
            if (method.getDeclaringClass() == clazz) {
                System.out.printf("  %-20s (declared in OrderService)%n", method.getName());
                publicCount++;
            }
        }
        System.out.println("  ... plus " + (clazz.getMethods().length - publicCount)
            + " inherited public methods from Object");

        System.out.println();

        System.out.println("=== getDeclaredFields() - ALL fields in THIS class ===");
        for (Field field : clazz.getDeclaredFields()) {
            String access = Modifier.toString(field.getModifiers());
            System.out.printf("  %-25s %-15s type=%s%n",
                access, field.getName(), field.getType().getSimpleName());
        }
    }
}

Output:
=== getDeclaredMethods() - ALL methods in THIS class ===
  public       processOrder         params=2
  private      validateOrder        params=1
  protected    checkInventory       params=1
  public static resetCounters       params=0

=== getMethods() - only PUBLIC methods, including inherited ===
  processOrder         (declared in OrderService)
  resetCounters        (declared in OrderService)
  status               (declared in OrderService)
  ... plus 9 inherited public methods from Object

=== getDeclaredFields() - ALL fields in THIS class ===
  private final          serviceId       type=String
  private                processedCount  type=int
  public                 status          type=String

Invoking Methods and Reading Fields

Java

Try it out

// File: InvocationDemo.java

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class InvocationDemo {

    static class InventoryService {
        private int stockCount = 100;
        private String warehouseId = "WH-NORTH";

        public String checkAvailability(String productId) {
            return stockCount > 0 ? productId + " in stock (" + stockCount + ")" : productId + " out of stock";
        }

        private void adjustStock(int delta) {
            stockCount += delta;
            System.out.println("  Stock adjusted by " + delta + " -> new count: " + stockCount);
        }
    }

    public static void main(String[] args) throws Exception {
        InventoryService service = new InventoryService();

        System.out.println("=== Invoking a public method via reflection ===");
        Method checkMethod = InventoryService.class
            .getDeclaredMethod("checkAvailability", String.class);
        // invoke(instance, arg1, arg2, ...) - first arg is the object,
        // rest are the method's parameters
        Object result = checkMethod.invoke(service, "LAPTOP-PRO-16");
        System.out.println("Result: " + result);

        System.out.println();

        System.out.println("=== Invoking a PRIVATE method via reflection ===");
        Method adjustMethod = InventoryService.class
            .getDeclaredMethod("adjustStock", int.class);
        // setAccessible(true) overrides access control for this Method object
        // Required for private/protected methods called from outside the class
        adjustMethod.setAccessible(true);
        adjustMethod.invoke(service, -10);

        System.out.println();

        System.out.println("=== Reading a private field via reflection ===");
        Field stockField = InventoryService.class.getDeclaredField("stockCount");
        stockField.setAccessible(true);
        int currentStock = (int) stockField.get(service);
        System.out.println("stockCount field value: " + currentStock);

        System.out.println();

        System.out.println("=== Writing to a private field via reflection ===");
        Field warehouseField = InventoryService.class.getDeclaredField("warehouseId");
        warehouseField.setAccessible(true);
        warehouseField.set(service, "WH-SOUTH");
        System.out.println("warehouseId after set: " + warehouseField.get(service));

        System.out.println();

        System.out.println("=== Verify change via the public method ===");
        System.out.println(checkMethod.invoke(service, "MOUSE-WIRELESS"));
    }
}

Output:
=== Invoking a public method via reflection ===
Result: LAPTOP-PRO-16 in stock (100)

=== Invoking a PRIVATE method via reflection ===
  Stock adjusted by -10 -> new count: 90

=== Reading a private field via reflection ===
stockCount field value: 90

=== Writing to a private field via reflection ===
warehouseId after set: WH-SOUTH

=== Verify change via the public method ===
MOUSE-WIRELESS in stock (90)

Creating Instances via Reflection

Java

Try it out

// File: DynamicInstantiationDemo.java

import java.lang.reflect.Constructor;

public class DynamicInstantiationDemo {

    static class NotificationSender {
        private final String channel;
        private final String endpoint;

        public NotificationSender(String channel, String endpoint) {
            this.channel = channel;
            this.endpoint = endpoint;
        }

        public void send(String message) {
            System.out.println("  [" + channel + "] -> " + endpoint + ": " + message);
        }
    }

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

        System.out.println("=== Creating instances dynamically via Constructor reflection ===");

        Constructor<NotificationSender> constructor = NotificationSender.class
            .getDeclaredConstructor(String.class, String.class);

        // Simulate a factory that creates different channel senders
        // from configuration data - the class name comes from config,
        // not hardcoded in this method
        String[][] channelConfigs = {
            {"SMS",  "sms-gateway.internal"},
            {"PUSH", "fcm.googleapis.com"},
            {"EMAIL","smtp.sendgrid.net"}
        };

        for (String[] config : channelConfigs) {
            NotificationSender sender = constructor.newInstance(config[0], config[1]);
            sender.send("Order ORD-8001 confirmed");
        }
    }
}

Output:
=== Creating instances dynamically via Constructor reflection ===
  [SMS] -> sms-gateway.internal: Order ORD-8001 confirmed
  [PUSH] -> fcm.googleapis.com: Order ORD-8001 confirmed
  [EMAIL] -> smtp.sendgrid.net: Order ORD-8001 confirmed

Reading Annotations via Reflection

Reading annotations is one of the most common and legitimate uses of reflection in production code. The runtime annotation reading covered in the custom annotations article works entirely through these methods.

Java

Try it out

// File: AnnotationReflectionDemo.java

import java.lang.annotation.*;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class AnnotationReflectionDemo {

    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.TYPE)
    @interface ServiceConfig {
        String name();
        boolean async() default false;
    }

    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    @interface RateLimit {
        int requestsPerMinute() default 60;
    }

    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.FIELD)
    @interface Inject {
        String qualifier() default "";
    }

    @ServiceConfig(name = "wallet-service", async = true)
    static class WalletService {

        @Inject(qualifier = "primary-datasource")
        private String dataSource;

        @RateLimit(requestsPerMinute = 100)
        public double getBalance(String userId) { return 0.0; }

        @RateLimit(requestsPerMinute = 10)
        public boolean transfer(String from, String to, double amount) { return true; }

        public String ping() { return "pong"; }
    }

    public static void main(String[] args) throws Exception {
        Class<WalletService> clazz = WalletService.class;

        System.out.println("=== Reading a class-level annotation ===");
        ServiceConfig config = clazz.getAnnotation(ServiceConfig.class);
        if (config != null) {
            System.out.println("Service name : " + config.name());
            System.out.println("Async        : " + config.async());
        }

        System.out.println();

        System.out.println("=== Reading method-level annotations ===");
        for (Method method : clazz.getDeclaredMethods()) {
            RateLimit rateLimit = method.getAnnotation(RateLimit.class);
            if (rateLimit != null) {
                System.out.printf("  %-12s rate-limit=%d req/min%n",
                    method.getName(), rateLimit.requestsPerMinute());
            } else {
                System.out.printf("  %-12s no rate limit%n", method.getName());
            }
        }

        System.out.println();

        System.out.println("=== Reading field-level annotations ===");
        for (Field field : clazz.getDeclaredFields()) {
            Inject inject = field.getAnnotation(Inject.class);
            if (inject != null) {
                System.out.printf("  @Inject field %-15s qualifier='%s'%n",
                    field.getName(), inject.qualifier());
            }
        }
    }
}

Output:
=== Reading a class-level annotation ===
Service name : wallet-service
Async        : true

=== Reading method-level annotations ===
  getBalance   rate-limit=100 req/min
  transfer     rate-limit=10 req/min
  ping         no rate limit

=== Reading field-level annotations ===
  @Inject field dataSource      qualifier='primary-datasource'

Real-World Example - Meesho Generic Object Mapper

A seller data platform ingests product information from multiple external seller feeds, each with slightly different field names. A @FieldMapping custom annotation marks how each internal model field maps to an external source field, and a generic ObjectMapper uses reflection to apply the mapping at runtime - no if (source == "FLIPKART_FEED") branches, no per-source parsing method, just annotations on the model and one generic mapper that handles them all.

Java

Try it out

// File: FieldMapping.java

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface FieldMapping {
    String sourceField();
    boolean required() default false;
    String defaultValue() default "";
}

Java

Try it out

// File: ProductListing.java

public class ProductListing {

    @FieldMapping(sourceField = "product_title", required = true)
    private String title;

    @FieldMapping(sourceField = "seller_sku", required = true)
    private String sku;

    @FieldMapping(sourceField = "price_inr", required = true)
    private String price;

    @FieldMapping(sourceField = "stock_qty", defaultValue = "0")
    private String stockQuantity;

    @FieldMapping(sourceField = "brand_name", defaultValue = "Unbranded")
    private String brand;

    // No @FieldMapping - this field is never mapped from external data
    private String internalNotes;

    @Override
    public String toString() {
        return "ProductListing[title=" + title + ", sku=" + sku
            + ", price=" + price + ", stock=" + stockQuantity
            + ", brand=" + brand + "]";
    }
}

Java

Try it out

// File: ReflectiveObjectMapper.java

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class ReflectiveObjectMapper {

    public <T> T map(Map<String, String> sourceData, Class<T> targetClass) throws Exception {
        T instance = targetClass.getDeclaredConstructor().newInstance();
        List<String> missingRequired = new ArrayList<>();

        for (Field field : targetClass.getDeclaredFields()) {
            FieldMapping mapping = field.getAnnotation(FieldMapping.class);

            if (mapping == null) {
                continue; // skip fields with no @FieldMapping
            }

            String sourceValue = sourceData.get(mapping.sourceField());

            if (sourceValue == null || sourceValue.isBlank()) {
                if (mapping.required()) {
                    missingRequired.add(mapping.sourceField());
                    continue;
                }
                sourceValue = mapping.defaultValue();
            }

            field.setAccessible(true);
            field.set(instance, sourceValue);
        }

        if (!missingRequired.isEmpty()) {
            throw new IllegalArgumentException(
                "Missing required fields: " + missingRequired);
        }

        return instance;
    }
}

Java

Try it out

// File: SellerFeedMapperDemo.java

import java.util.HashMap;
import java.util.Map;

public class SellerFeedMapperDemo {

    public static void main(String[] args) throws Exception {
        ReflectiveObjectMapper mapper = new ReflectiveObjectMapper();

        System.out.println("=== Mapping a complete seller feed record ===");
        Map<String, String> completeFeed = new HashMap<>();
        completeFeed.put("product_title", "Wireless Noise-Cancelling Headphones");
        completeFeed.put("seller_sku",    "SKU-WNC-2024");
        completeFeed.put("price_inr",     "3499");
        completeFeed.put("stock_qty",     "85");
        completeFeed.put("brand_name",    "SoundWave");

        ProductListing complete = mapper.map(completeFeed, ProductListing.class);
        System.out.println(complete);

        System.out.println();

        System.out.println("=== Mapping with optional fields absent - defaults applied ===");
        Map<String, String> partialFeed = new HashMap<>();
        partialFeed.put("product_title", "USB-C Charging Cable");
        partialFeed.put("seller_sku",    "SKU-USBC-001");
        partialFeed.put("price_inr",     "299");
        // stock_qty absent -> default "0"
        // brand_name absent -> default "Unbranded"

        ProductListing partial = mapper.map(partialFeed, ProductListing.class);
        System.out.println(partial);

        System.out.println();

        System.out.println("=== Mapping with a required field missing - error thrown ===");
        Map<String, String> invalidFeed = new HashMap<>();
        invalidFeed.put("product_title", "Bluetooth Speaker");
        // seller_sku is REQUIRED but absent
        invalidFeed.put("price_inr", "999");

        try {
            mapper.map(invalidFeed, ProductListing.class);
        } catch (IllegalArgumentException e) {
            System.out.println("Mapping failed: " + e.getMessage());
        }
    }
}

Output:
=== Mapping a complete seller feed record ===
ProductListing[title=Wireless Noise-Cancelling Headphones, sku=SKU-WNC-2024, price=3499, stock=85, brand=SoundWave]

=== Mapping with optional fields absent - defaults applied ===
ProductListing[title=USB-C Charging Cable, sku=SKU-USBC-001, price=299, stock=0, brand=Unbranded]

=== Mapping with a required field missing - error thrown ===
Mapping failed: Missing required fields: [seller_sku]

ReflectiveObjectMapper maps any class annotated with @FieldMapping - not just ProductListing. Adding a new seller data model means creating a new class with @FieldMapping annotations, and the same mapper handles it with no changes. This is exactly how Jackson's ObjectMapper, ModelMapper, and MapStruct work - the annotation-plus-reflection pattern at the foundation of every mapping framework.

Reflection API - Key Methods Reference

Starting Point	Method	Returns	Notes
`Class`	`getDeclaredMethods()`	`Method[]`	All methods in this class, all access levels, no inherited
`Class`	`getMethods()`	`Method[]`	Public methods only, includes inherited
`Class`	`getDeclaredFields()`	`Field[]`	All fields in this class, all access levels, no inherited
`Class`	`getDeclaredMethod(name, paramTypes)`	`Method`	Throws `NoSuchMethodException` if not found
`Class`	`getDeclaredField(name)`	`Field`	Throws `NoSuchFieldException` if not found
`Class`	`getAnnotation(annotationClass)`	`T extends Annotation`	`null` if absent or retention not RUNTIME
`Class`	`getDeclaredConstructors()`	`Constructor[]`	All constructors
`Class`	`getSuperclass()`	`Class<?>`	Direct superclass; `null` for `Object` and interfaces
`Method`	`invoke(instance, args)`	`Object`	`null` instance for static methods
`Method`	`getAnnotation(annotationClass)`	`T extends Annotation`	Method-level annotation
`Field`	`get(instance)`	`Object`	Requires `setAccessible(true)` for private
`Field`	`set(instance, value)`	`void`	Requires `setAccessible(true)` for private

Best Practices

Prefer compile-time alternatives wherever they exist. Reflection is a runtime mechanism with real costs: it bypasses compiler type-checking, produces Object returns that require casts, and throws checked exceptions that pollute method signatures. When you know the type at compile time, use it directly. Reflection belongs in framework code and tools that genuinely cannot know types at compile time - not in application business logic.

Cache Method, Field, and Constructor objects rather than looking them up repeatedly. getDeclaredMethod() and getDeclaredField() are not free - they scan the class's method/field table and create new wrapper objects. Calling them inside a loop or on every request is a measurable performance tax. Look them up once at startup or initialization, store them in a static final variable or a map, and reuse them.

Call setAccessible(true) once per Method or Field object, not on each call. The access check happens during setAccessible - once it is set, subsequent invoke() or get() calls skip the check. Calling setAccessible(true) every time is redundant and slightly wasteful.

Wrap reflection exceptions with meaningful domain messages before rethrowing. InvocationTargetException, NoSuchMethodException, IllegalAccessException, and IllegalArgumentException are all checked or unchecked exceptions that raw reflection throws. Catching them and rethrowing as IllegalStateException("Failed to read field '" + field.getName() + "' from " + obj.getClass().getSimpleName()) makes the error diagnosable without requiring the caller to understand reflection internals.

In Java 9+ modules, open packages that need deep reflection. setAccessible(true) on a field or method in an unopened module package throws InaccessibleObjectException. If you control the module, add opens com.example.model to your.framework in module-info.java. If you do not, the command-line --add-opens flag is the standard workaround that frameworks document for their users.

Common Mistakes

Mistake 1 - Calling getDeclaredMethod Each Time Instead of Caching

Java

Try it out

import java.lang.reflect.Method;

// WRONG - getDeclaredMethod scans the class's method table and
// constructs a new Method object on every single call. In a hot
// path (called per request, per item in a batch, inside a loop),
// this creates measurable garbage and CPU overhead.
class ReflectionInHotPath {
    void processEveryOrder(Object service, String orderId) throws Exception {
        Method method = service.getClass()
            .getDeclaredMethod("processOrder", String.class); // scans every time
        method.setAccessible(true);
        method.invoke(service, orderId);
    }
}

// CORRECT - look up the Method object once, at initialization time,
// and reuse it for every invocation. The setAccessible(true) call
// also only needs to happen once.
class ReflectionCached {
    private final Method processOrderMethod;

    ReflectionCached(Class<?> serviceClass) throws NoSuchMethodException {
        this.processOrderMethod = serviceClass
            .getDeclaredMethod("processOrder", String.class);
        this.processOrderMethod.setAccessible(true);
    }

    void processEveryOrder(Object service, String orderId) throws Exception {
        processOrderMethod.invoke(service, orderId); // reuses the cached Method
    }
}

Mistake 2 - Ignoring InvocationTargetException Inner Cause

Java

Try it out

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

// WRONG - catching InvocationTargetException and logging it directly
// shows the WRAPPER exception, not the REAL exception the method threw.
// The stack trace points to the reflection call, not the actual error.
class WrongExceptionHandling {
    static void invoke(Object target, Method method, Object... args) {
        try {
            method.invoke(target, args);
        } catch (InvocationTargetException e) {
            System.err.println("Error: " + e.getMessage()); // prints "null" or wrapper info
        } catch (Exception e) {
            System.err.println("Error: " + e);
        }
    }
}

// CORRECT - extract getCause() from InvocationTargetException to get
// the actual exception thrown by the invoked method
class CorrectExceptionHandling {
    static void invoke(Object target, Method method, Object... args) throws Exception {
        try {
            method.invoke(target, args);
        } catch (InvocationTargetException ite) {
            Throwable actualCause = ite.getCause();
            // rethrow the real cause - this is what callers actually need to see
            if (actualCause instanceof Exception exception) throw exception;
            throw new RuntimeException("Unexpected error during reflective invocation", actualCause);
        }
        // IllegalAccessException is a programming error - let it propagate
    }
}

Mistake 3 - Using getMethods() When getDeclaredMethods() Is Needed (or Vice Versa)

Java

Try it out

import java.lang.reflect.Method;
import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface Internal {}

class BaseService {
    @Internal
    public void legacyMethod() {}
}

class ConcreteService extends BaseService {
    @Internal
    public void newMethod() {}

    private void helperMethod() {}
}

class WrongMethodFetch {
    static void demo() {
        // WRONG for finding @Internal on PRIVATE methods -
        // getMethods() returns only PUBLIC methods, including inherited.
        // It WILL find legacyMethod() from BaseService (inherited, public)
        // but WILL NOT find helperMethod() (private, not returned by getMethods())
        for (Method m : ConcreteService.class.getMethods()) {
            if (m.isAnnotationPresent(Internal.class)) {
                System.out.println("Found via getMethods: " + m.getName());
                // Finds both newMethod and legacyMethod (inherited)
                // but misses all private methods
            }
        }

        // CORRECT for finding annotations on ALL methods in THIS class,
        // including private - getDeclaredMethods() returns all access levels
        // but ONLY from ConcreteService itself, not inherited ones
        for (Method m : ConcreteService.class.getDeclaredMethods()) {
            if (m.isAnnotationPresent(Internal.class)) {
                System.out.println("Found via getDeclared: " + m.getName());
                // Finds newMethod but NOT legacyMethod (that is on BaseService)
            }
        }
    }
}

Mistake 4 - Accessing Fields of a Superclass Via the Subclass

Java

Try it out

import java.lang.reflect.Field;

// WRONG - getDeclaredFields() on the SUBCLASS returns fields declared
// in the subclass ONLY. Fields declared in the SUPERCLASS are not
// returned even though they are part of the object's state.
// getDeclaredField("baseField") on the subclass throws NoSuchFieldException.
class Base {
    private String baseField = "base-value";
}

class Child extends Base {
    private String childField = "child-value";
}

class WrongFieldAccess {
    static void demo() throws Exception {
        Child child = new Child();

        // This throws NoSuchFieldException - "baseField" is on Base, not Child
        try {
            Field field = Child.class.getDeclaredField("baseField"); // THROWS
        } catch (NoSuchFieldException e) {
            System.out.println("Not found on Child - must look on Base");
        }
    }
}

// CORRECT - walk the class hierarchy to find fields from superclasses
class CorrectFieldAccess {
    static Field findField(Class<?> clazz, String fieldName) throws NoSuchFieldException {
        while (clazz != null) {
            try {
                return clazz.getDeclaredField(fieldName);
            } catch (NoSuchFieldException e) {
                clazz = clazz.getSuperclass(); // move up to the parent class
            }
        }
        throw new NoSuchFieldException(fieldName);
    }
}

Interview Questions

Q1. What is the Java Reflection API and what are its primary use cases?

The Reflection API allows Java code to inspect and interact with the structure of classes, methods, fields, and constructors at runtime, without compile-time knowledge of those elements. The primary entry point is java.lang.Class, from which you can obtain Method, Field, and Constructor objects representing program elements. Primary use cases are: framework internals (Spring's dependency injection, JUnit's test runner, Jackson's serialization), annotation-driven processing (reading custom annotations to apply cross-cutting behavior), dynamic proxies and AOP, and tools like IDEs and debuggers that need to inspect arbitrary classes. Application business logic almost never needs reflection directly - it is a framework and tooling mechanism.

Q2. What is the difference between getDeclaredMethods() and getMethods()?

getDeclaredMethods() returns all methods declared directly in the class - public, protected, package-private, and private - but does not include inherited methods from superclasses or interfaces. getMethods() returns only public methods, but includes those inherited from superclasses and interfaces all the way up the hierarchy. For reflection-based processors that need to reach private fields or methods, getDeclaredMethods() combined with setAccessible(true) is the correct pattern. For processors that need to find all callable public APIs including inherited ones, getMethods() is appropriate. Most framework code uses getDeclaredMethods() and walks the class hierarchy manually when needed.

Q3. What does setAccessible(true) do, and when is it required?

setAccessible(true) on a Method, Field, or Constructor object tells the JVM to bypass Java's access control checks for that specific reflective operation. Without it, attempting to call invoke() on a private method or get() on a private field throws IllegalAccessException. It is required whenever reflection is used to access private or protected members from outside their declaring class - which is how ORM frameworks read entity fields, how dependency injection frameworks populate private fields, and how test utilities access internals for assertion. In Java 9+ with the module system, setAccessible may throw InaccessibleObjectException if the package is not opened in module-info.java, requiring explicit module opens.

Q4. Why is reflection performance-sensitive, and how do frameworks mitigate this?

Reflection is slower than direct method calls for several reasons: getDeclaredMethod() and getDeclaredField() scan the class's metadata and construct new objects on every call, invoke() performs access checks and type validation on each invocation, and reflective calls prevent certain JIT compiler optimizations that direct calls benefit from. Frameworks mitigate this by caching Method, Field, and Constructor objects after the first lookup, calling setAccessible(true) once on the cached object, and using MethodHandle (introduced in Java 7) or generated bytecode (as many AOP and ORM frameworks do) for hot paths where the reflective call is made millions of times per second. One-time startup reflection is generally acceptable; per-request or per-item reflection on hot paths requires careful caching.

Q5. What happens when you call method.invoke() and the invoked method throws an exception?

When a method invoked via method.invoke() throws any exception (checked or unchecked), it is wrapped in InvocationTargetException before being thrown from invoke() itself. The actual exception thrown by the method is accessible via invocationTargetException.getCause(). A common mistake is catching InvocationTargetException and logging or rethrowing it directly, which gives the wrong stack trace and obscures the real error. Correct handling always calls getCause() to extract and process the real exception. If the invoked method is declared to throw a specific checked exception and the caller needs to propagate it, getCause() should be cast appropriately before rethrowing.

Q6. How does Class.forName() differ from ClassName.class, and why do frameworks prefer it?

ClassName.class is a compile-time constant - it requires the class to be imported and available at compile time, and the compiler resolves it to the Class object directly. Class.forName("fully.qualified.ClassName") loads the class by string name at runtime - it can load classes that did not exist when the calling code was compiled, and it can be configured externally (from a config file, a database value, a classpath scan). Frameworks prefer Class.forName or classpath scanning because they are compiled independently of application code: Spring's AnnotationConfigApplicationContext finds PaymentService by scanning the classpath for classes annotated @Component, loading each one via its string name, and working with it via the Class object - with no compile-time dependency on PaymentService in Spring's own code.

FAQs

Can reflection access static fields and static methods?

Yes. For static members, pass null as the instance argument to method.invoke(null, args) and field.get(null) or field.set(null, value). The null signals that there is no instance - the operation applies to the class itself. Static private members still require setAccessible(true) to be read or invoked from outside the class.

Can reflection modify a final field?

In Java versions before 17, calling field.setAccessible(true) on a final field and then field.set(instance, value) could change the field's value in the heap object - it bypasses the compiler's final enforcement. However, the JIT compiler may have already inlined the field's original value at any call site that read it as a constant, so the visible effect was unreliable. From Java 17 onward, the JDK strengthened these restrictions as part of the ongoing encapsulation work - the JEP 403 (--illegal-access removed) and related changes make modifying final fields via reflection unreliable and unsupported. Treat final fields as immutable from a reflection standpoint.

What is the difference between getClass() on an object and the .class literal?

object.getClass() returns the runtime class of the object - the actual instantiated type. If PaymentProcessor processor = new UpiProcessor(), then processor.getClass() returns Class<UpiProcessor>, not Class<PaymentProcessor>. PaymentProcessor.class always returns the Class object for PaymentProcessor, regardless of any subclass. For reflection-based processing that should inspect the actual type being used (reading fields of the real object, finding methods the subclass might have overridden), getClass() on the instance is the right choice.

Does reflection work with records?

Yes. A record is a regular class from the JVM's perspective - getDeclaredFields(), getDeclaredMethods(), and getAnnotation() all work on records the same way they work on regular classes. The generated accessor methods (like name(), age()) are visible via getDeclaredMethods(). The canonical constructor is accessible via getDeclaredConstructors(). There are also record-specific methods: clazz.isRecord() returns true for record types, and clazz.getRecordComponents() returns the record's components as RecordComponent[] objects, each carrying the component's name, type, and annotations - useful for annotation-driven mappers that want to work natively with records.

Can reflection be used to call a method on a null object?

Only for static methods - method.invoke(null, args) is valid when the method is static. For instance methods, passing null as the target object throws NullPointerException. This matches what a direct call would do: calling an instance method on null throws NullPointerException regardless of how the call is made.

Is reflection thread-safe?

Reading class structure via getDeclaredMethods(), getDeclaredFields(), getAnnotation(), and similar inspection methods is safe to call concurrently - the Class object's structural metadata does not change after class loading. method.invoke() and field.get/set() are as thread-safe as the underlying method or field they interact with - if the method modifies shared mutable state, concurrent reflective invocations of it carry the same risks as concurrent direct invocations. setAccessible(true) itself is an operation on the Method or Field object - if multiple threads share and concurrently modify the same Method object (calling setAccessible on the same object from different threads), that can be a race. The standard practice is to call setAccessible(true) once during initialization on a dedicated cached object, which eliminates the concern.

Summary

The Reflection API is the runtime mechanism that makes Java frameworks possible - it lets code written without knowledge of your classes inspect those classes, find their annotations, read their fields, and invoke their methods at runtime. The entry point is always a Class object; from it you reach Method, Field, and Constructor objects that represent the class's structure. getDeclaredMethods() and getDeclaredFields() give you everything declared in one class at all access levels; getMethods() and getFields() give you only public members including inherited ones. setAccessible(true) bypasses access control for private members and is required by any code that needs to reach non-public internals.

The practical rules: cache Method and Field objects rather than looking them up per call. Always extract getCause() from InvocationTargetException to see the real error. Walk the class hierarchy explicitly when you need fields from superclasses. And recognize that Class.forName() is the reason frameworks can discover and use your classes without importing them - it is the bridge between a string name in a configuration file or classpath scan and a live, usable type in memory.

Understanding reflection at this level is what separates a developer who uses Spring from one who could build a simple version of it.