This makes reflection a very powerful technique—so it's important to understand
when we should use it, and when it's overkill.
When to Use Relection
Many, if not most Java frameworks use reflection in some capacity. Writing architec‐
tures that are flexible enough to cope with code that is unknown until runtime usu‐
ally requires reflection. For example, plug-in architectures, debuggers, code brows‐
ers and REPL-like environments are usually implemented on top of reflection.
Reflection is also widely used in testing, for example by the JUnit and TestNG libra‐
ries, and for mock object creation. If you've used any kind of Java framework then
you have almost certainly been using reflective code, even if you didn't realize it.
To start using the Reflection API in your own code, the most important thing to
realize is that it is about accessing objects where virtually no information is known,
and that the interactions can be cumbersome because of this.
R e l e c t i o n
Wherever possible, if some static information is known about dynamically loaded
classes (e.g., that the classes loaded all implement a known interface), then this can
greatly simplify the interaction with the classes and reduce the burden of operating
It is a common mistake to try to create a reflective framework that tries to account
for all possible circumstances, instead of dealing only with the cases that are imme‐
diately applicable to the problem domain.
How to Use Relection
The first step in any reflective operation is to get a Class object representing the
type to be operated on. From this, other objects, representing fields, methods, or
constructors can be accessed, and applied to instances of the unknown type.
To get an instance of an unknown type, the simplest way is to use the no-arg con‐
structor, which is made available directly via the Class object:
Class <?> clz = getSomeClassObject ();
Object rcvr = clz . newInstance ();
For constructors that take arguments, you will have to look up the precise construc‐
tor needed, represented as a Constructor object.
The Method objects are one of the most commonly used objects provided by Reflec‐
tion. We'll discuss them in detail—the Constructor and Field objects are similar in
A class object contains a Method object for each method on the class. These are
lazily created after classloading, and so aren't immediately visible in an IDE's