Reflection

New words in this topic, in plain English. Come back here whenever one feels fuzzy.

Reflection

A running program looking at, and using, its own classes, methods and fields as data.

Class object

The single object of type Class that the JVM creates for each loaded class. It describes the class's members.

Member

A field, method or constructor of a class.

Declared member

A member written in that class itself, not inherited from a parent class.

invoke

Calling a method through its Method object instead of writing the call in the code.

setAccessible

A switch on a Field, Method or Constructor object that turns off Java's private/protected checks for reflective use.

Strong encapsulation

The module system's rule that code outside a module can't reach its non-exported or non-opened packages, even with reflection.

Dynamic proxy

An object created at runtime that implements chosen interfaces and sends every method call to one handler method.

1. 1

   Spot the synthetic members

   In "Inspecting a class", add public Runnable printer() { return () -> System.out.println(name); } to Product. Predict the new method list, then run. A lambda$printer$0 method appears: the compiler turned the lambda body into a private synthetic method. Filter it out with if (m.isSynthetic()) continue;.

2. 2

   Look up the wrong overload

   In "Creating, invoking and touching private state", change getDeclaredMethod("applyDiscount", int.class) to long.class. Predict the exception. You get java.lang.NoSuchMethodException: Product.applyDiscount(long): parameter types must match exactly; no widening happens at lookup.

3. 3

   Let the wrapper escape

   In the proxy example, replace throw e.getCause(); with throw e;. Run it: the caller's catch (IllegalArgumentException e) no longer matches, and the program dies with java.lang.reflect.UndeclaredThrowableException, because the interface method doesn't declare the checked InvocationTargetException.

Errors are the best teachers. Make each change, read the error, guess what went wrong, then reveal the answer.

1. 1

   Every loaded class has exactly one **Class object** describing it. You get it three ways: Product.class (a class literal, known at compile time), obj.getClass() (the runtime class of an object) or Class.forName("com.shop.Product") (by name, at runtime, which may throw ClassNotFoundException). From the Class you reach Field, Method and Constructor objects, plus the superclass, interfaces, modifiers and annotations.

2. 2

   There are two families of lookup methods. **getFields(), getMethods(), getConstructors() return only public members, including inherited ones. getDeclaredFields(), getDeclaredMethods(), getDeclaredConstructors() return every member declared in that class itself, of any visibility, but nothing inherited. The order of the returned arrays is not specified**, so sort them if you print them.

3. 3

   With a member in hand you can act: constructor.newInstance(args) creates an object, method.invoke(target, args) calls a method (pass null as the target for a static method), and field.get(obj) / field.set(obj, value) read and write a field. Arguments and results are Objects, so primitives are boxed. If the called method throws, you get an **InvocationTargetException** whose getCause() is the real exception.

4. 4

   Access rules still apply: touching a private member from another class throws IllegalAccessException unless you first call **setAccessible(true)**, which switches off the language access check for that one Field/Method/Constructor object. Since Java 9 the module system adds a second wall: setAccessible on a member of a package that its module doesn't open to you throws InaccessibleObjectException. Java 16 made this strong encapsulation the default for the JDK (JEP 396), and Java 17 removed the --illegal-access escape hatch (JEP 403).

5. 5

   Reflection has costs. A reflective call does access checks, boxes arguments into an Object[], and wraps exceptions; it's slower than a direct call, especially when the Method lookup is repeated each time (lookups scan and copy member arrays). Errors that the compiler would catch, like a misspelled method name or wrong argument type, become runtime exceptions. Refactoring tools can't see string-based calls, so renaming a method silently breaks getMethod("oldName").

6. 6

   Use reflection for framework and tooling code: dependency injection, serialization (Jackson, Gson), ORMs (Hibernate), test runners (JUnit), plug-in loading, and debuggers. In application code, prefer interfaces and polymorphism. Related, faster APIs exist: **MethodHandle (Java 7) and VarHandle** (Java 9) in java.lang.invoke, and dynamic proxies (java.lang.reflect.Proxy) that implement interfaces at runtime.

• ↔

  Reflection makes generic frameworks possible (one serializer for every class) but moves errors from compile time to runtime.

• ↔

  setAccessible gives access to private state that frameworks need, but breaks the encapsulation that keeps classes safe to change.

• ↔

  Runtime reflection needs no build step; build-time code generation is faster at startup and checked by the compiler, but adds generated code and tooling.

• Done when you can get a Class object three ways and list its declared fields, methods and constructors in a stable order.

• Done when you can create objects, invoke methods and read fields reflectively, and unwrap InvocationTargetException.

• Done when you can explain getMethods versus getDeclaredMethods.

• Done when you can explain why setAccessible fails on JDK internals since Java 16/17 and what --add-opens does.

• Done when you can build a dynamic proxy and name the costs of reflection and its alternatives.