Java Reflection API

Reflection is the capability of Java code to inspect and interact with class metadata and members at runtime.

It enables dynamic behavior when types are unknown at compile time.

java.lang.reflect.

Runtime metadata for classes, interfaces, enums, annotations, arrays, and primitives.

• MyType.class
• obj.getClass()
• Class.forName("com.example.MyType")

Loading classes dynamically by fully qualified name.

Fields, methods, constructors, modifiers, annotations, superclass, interfaces, generics metadata.

Metadata and access handle for a class variable/member.

Metadata and invocation handle for a class method.

Metadata and invocation handle for constructing instances.

clazz.getMethods().

clazz.getDeclaredMethods().

getField() resolves public (including inherited); getDeclaredField() resolves declared in that class (any visibility).

getMethods() includes inherited public methods; getDeclaredMethods() includes all declared methods in that class only.

field.get(target) (or primitive-specific getters).

field.set(target, value).

method.invoke(target, args...).

Pass null as the target instance.

clazz.getDeclaredConstructor(...).newInstance(...).

Poor exception behavior and no-arg-only limitations; use constructor APIs instead.

Wrapper exception thrown when invoked method itself throws an exception.

Thrown when reflective access violates visibility/access rules.

Thrown when a method with the requested signature is not found.

Thrown when requested field is absent.

Bypass Java language access checks for reflective member access.

No; module encapsulation/security constraints can block it.

Use member.getModifiers() with Modifier helper methods.

Modifier.isPublic(method.getModifiers()).

Modifier.isStatic(method.getModifiers()).

clazz.isInterface().

clazz.isEnum().

clazz.isAnnotation().

clazz.getSuperclass().

clazz.getInterfaces().

As special classes where isArray() is true.

clazz.getComponentType().

Yes, with java.lang.reflect.Array.newInstance().

As literals like int.class, boolean.class.

Alias for primitive int.class.

Reading annotations via reflection during execution.

clazz.getAnnotation(MyAnnotation.class).

RetentionPolicy.RUNTIME.

No.

Interface implemented by reflection elements that can carry annotations.

Checks runtime type compatibility relationship.

Number.class.isAssignableFrom(Integer.class) returns true.

No, many errors are deferred to runtime.

Extra checks, indirection, boxing, and limited JIT inlining opportunities.

It can bypass access checks in some conditions, so use carefully.

Reflection objects are mostly immutable metadata, but target object mutation still needs synchronization.

No, do not rely on order of returned members.

method.getReturnType().

method.getParameterTypes().

constructor.getParameterTypes().

method.getExceptionTypes().

Use isSynthetic().

method.isVarArgs().

It adds complexity and runtime failure modes without benefits in static scenarios.

Simple plugin loading, testing utilities, annotation-driven configuration.

Prefer direct code first; use reflection only for explicit dynamic needs.

Generic type parameters are mostly removed at runtime, limiting reflective generic precision.

getGenericType(), getGenericReturnType(), getGenericParameterTypes(), etc.

Root abstraction for Java types beyond raw Class.

Class, ParameterizedType, TypeVariable, WildcardType, GenericArrayType.

Represents parameterized forms like List<String>.

Represents type parameters like T in class Box<T>.

Represents wildcards such as ? extends Number.

Represents array types whose component is a parameterized/type-variable type.

No, not reliably due to erasure.

Compiler-generated method preserving polymorphism across erased generics boundaries.

You may see extra methods that are not explicitly declared in source.

clazz.getDeclaredClasses().

isAnonymousClass(), isLocalClass(), isMemberClass().

Signature matching may fail if wrapper/primitive types don’t match expected parameters.

Wrong argument count/type or improper varargs packaging.

method.getParameterAnnotations() or Parameter API.

Parameter objects (names, modifiers, annotations, synthetic flags).

Only when compiled with appropriate metadata (e.g., -parameters).

Declared variant only checks directly present annotation on that element.

Inheritance of class-level annotations only (not fields/methods).

Use getAnnotationsByType().

Repeated lookup is costly; caching improves throughput.

Resolved fields/methods/constructors, accessibility state, annotation presence.

Same class name loaded by different classloaders are distinct incompatible types.

Unexpected ClassCastException.

Frameworks use thread context loader to resolve app classes/resources in containers.

Runtime-generated classes implementing interfaces and delegating calls to handlers.

Proxy.newProxyInstance() with InvocationHandler.

They proxy interfaces, not concrete classes directly.

AOP interception, client stubs, transaction wrappers, metrics logging.

invoke(Object proxy, Method method, Object[] args).

Handle equals/hashCode/toString carefully to avoid surprises.

Introspector is property-centric; reflection is lower-level member-centric.

Metadata about bean properties/events/methods from JavaBeans introspection.

Discovers fields/getters/setters and type metadata dynamically.

Finds constructors/fields/methods and applies injection rules.

Maps entity members to columns and invokes accessors/constructors.

Strong encapsulation can deny deep reflection across module boundaries.

exports for public API access; opens for deep reflection access.

Opens a package at runtime to specific/all unnamed modules for reflective access.

They are unstable and often blocked by encapsulation.

Common checked superclass for many reflection-related exceptions.

Real failure is in getCause().

Match exact parameter type array and account for primitives/interfaces.

String-based member names/signatures become stale.

Use annotations/contracts and centralized lookup utilities.

Validate all required members at startup, not lazily in production traffic.

Speeds up debugging of signature/access/module mismatches.

Sometimes technically, but unsafe and can violate JVM assumptions.

Breaks immutability and may create visibility/optimization anomalies.

Reflection is flexible and simpler; codegen can offer better speed/type safety.

Annotation processing is compile-time; reflection is runtime.

When runtime overhead and startup scanning must be minimized.

Contract tests across representative classes and edge-case signatures.

Frequent dynamic access adjustments can add overhead and complexity.

Yes, but with strict input validation and limited scope.

Could expose dangerous behavior or internal APIs.

Whitelist packages/interfaces and verify signatures before invocation.

Restrict base packages and pre-index metadata.

Perform metadata resolution at boot and cache handles.

Prefer no; pre-resolve handles or use alternatives.

MethodHandle with stable call sites.

When late-binding flexibility outweighs performance/complexity costs.

Cache, constrain, validate, and isolate reflection behind small APIs.

Keep dynamic behavior at boundaries; keep core domain mostly static and type-safe.

Harder to inline and optimize compared to direct/static dispatch.

Argument boxing, arrays for varargs, and metadata path overhead.

Typed, potentially optimizable executable reference from java.lang.invoke.

Better performance characteristics and explicit lookup capabilities.

Modern typed variable-access API with atomic and memory-order semantics.

VarHandle is safer/faster for many low-level access patterns.

Transforming handles (bind, filter, fold, asType) to compose dynamic behavior.

Repeated runtime conversions and exception wrapping paths.

I/O + class metadata loading across many jars/classes.

Metadata indexes, narrowed scan roots, build-time generation.

Closed-world compilation requires explicit reflective metadata configuration.

Dynamic accesses not declared in hints/config are removed/inaccessible.

Generate code at build time and emit reflection hints automatically.

Strong refs to classes/members prevent class unloading in app servers/plugins.

Use weak references, scoped caches, and lifecycle cleanup hooks.

Non-open packages block private/member deep access across modules.

Define explicit opens for framework-needed packages, keep least privilege.

Inventory and review all deep reflection points for risk/perf/compliance.

Validate names/signatures, enforce interface constraints, deny dangerous packages.

Latency variance and overhead harm predictability.

Many target shapes reduce optimization opportunities and CPU efficiency.

Yes, opaque dynamic dispatch can obscure stack traces/ownership if badly instrumented.

Emit structured diagnostics: target class, member signature, module/access context.

Try fast pre-bound handle, then cached reflection, then fail-fast with context.

Interface-first APIs plus optional annotation metadata; reflection only for discovery/wiring.

Use explicit schema/version annotations and compatibility validators.

Private renames break runtime silently until exercised.

CI startup validation tests scanning required members.

Generating lookup tables at build/startup to avoid repeated runtime introspection.

Merging direct/meta/aliased annotation models (common in advanced frameworks).

Alias rules, inheritance, repeatables, and composed annotations interact subtly.

You can inspect permitted subclasses; still subject to module/access rules.

Record components are first-class metadata simplifying serializers/mappers.

Need specialized invocation logic (often MethodHandles) for default dispatch.

Historically constrained by security manager/policies; modern controls rely more on modules/process boundaries.

Privileged code executing untrusted reflective requests.

Capability boundaries, explicit allowlists, no raw user-controlled member dispatch.

Consistency, caching, auditing, and safer error handling.

Class name, loader, module, member signature, argument types, cause chain.

Yes; typed SPI reduces fragile string-based dynamic lookups.

Incremental codegen/MethodHandle adapters and stricter compile-time contracts.

Use reflection at configuration/bootstrap boundaries, typed calls in steady-state flow.

Defined acceptable startup and per-request overhead allocated to dynamic behavior.

Profile call counts, wall time, allocations, and p95/p99 latency impact.

Fail fast at startup for required bindings; graceful degradation for optional features.

Architecture reviews for new deep-reflection usage and module-open exceptions.

Target members, rationale, fallback behavior, and compatibility guarantees.

Using unrestricted reflection as core control flow instead of explicit contracts.

Framework internals, debugging complex runtime behavior, and performance tuning.

Constrained, cached, observable, secure, and justified by clear dynamic requirements.