Reflection isn't nescessarily related to recompilations. I think the
name "reflection" is supposed to convey the image of a Java program looking
at itself in a mirror, or in other words, to look at itself.

   For example, you might have an object which is an instance of Class. You
can query this object to find out what methods it has, and invoke these
methods. This would be using reflection, even if no (re)compilation was
involved.

   - Oliver

AFAIK, it doesn't have to do with recompiling - it has to do with, as
you said, dynamically accessing to classes.

For example:

String classname = "org.some.class.TestClass";
Object[] parameters;
Object obj =
Class.forName(classname).getConstructor(Object[].class).newInstance(new
Object[] { parameters });

What this code snippet does is:

Get the class named "org.some.class.TestClass".
(Class.forName(classname)).
Then it proceeds to get a constructor for said class, one that requires
an object array as parameter ( getConstructor(Object[].class)).
Then it proceeds to instantiate the object using said constructor,
passing the Object array "parameters" as the parameters.

There you have it - I have loaded an instance of the class
org.some.class.TestClass - without having to know that name in the code
- the String classname could have been loaded from any source (in
particular, I use that code snippet for persistence of simple objects
from a database - load the className and the constructor parameters
from the database, execute the reflection voodoo to instantiate)