Ability to inspect and manipulate classes, methods, fields, and constructors at runtime

Operates on metadata represented by the java.lang.Class object

Discovering type information dynamically (structure, annotations, modifiers)

Creating objects and invoking members without compile-time knowledge

JVM stores metadata for loaded classes

Reflection reads this metadata through Class, Method, Field, Constructor

SomeType.class

object.getClass()

Class.forName("fully.qualified.Name")

ClassLoader.loadClass(...)

Public members accessible via getMethods(), getFields(), etc.

Declared members (including private) via getDeclaredMethods(), getDeclaredFields()

Access checks can be bypassed (with restrictions) using setAccessible(true)

Instantiate via Constructor.newInstance(...) (or Class.getDeclaredConstructor(...).newInstance(...)

Invoke methods via Method.invoke(target, args...)

Read/write fields via Field.get(target) / Field.set(target, value)

Read annotations via getAnnotations(), getDeclaredAnnotations()

Access generic type info when available via java.lang.reflect.Type

Type identity and metadata access

Links to declared members, superclass, interfaces, annotations

Method, Field, Constructor

Modifier (public/private/static/final, etc.)

Parameter, Type, ParameterizedType

Proxies: java.lang.reflect.Proxy + InvocationHandler

Method handles (alternative): java.lang.invoke.MethodHandle (often faster, more direct)

Identify class by name or by instance

Enumerate methods/fields/constructors and modifiers

Discover annotations and parameter types

Construct instance, invoke methods, access fields

Checked exceptions: ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException

Component scanning and auto-wiring (e.g., Spring)

Creating objects based on configuration rather than direct new

Mapping fields to columns, populating entities dynamically (e.g., Hibernate/MyBatis)

Converting objects to/from JSON/XML/binary by inspecting fields/getters (e.g., Jackson/Gson)

Loading implementations by class name at runtime

Service discovery (e.g., SPI patterns)

Intercepting method calls for logging, transactions, security

Test runners discovering test methods by annotation

Debugging tools, profilers, object inspectors

Works when types are unknown at compile time

Enables generic libraries and framework-level automation

Reduce direct dependencies by late binding

Reflective calls are slower than direct invocation (though caching can help)

Accessing private members can break invariants and future compatibility

setAccessible(true) may be limited by security policies and strong encapsulation (Java 9+ modules)

Renaming members breaks string-based reflection unless handled with conventions/annotations

Interfaces, generics, dependency injection, service loaders

Store Method/Field/Constructor references to avoid repeated scanning

Avoid hard-coded strings when possible; centralize metadata

Use it only when necessary; consider module opens/export configuration

Fail fast with clear error messages when members/types are missing

MethodHandle, code generation (bytecode/ASM), or compile-time processing (annotation processors)