24.2. Key Concepts of Reflection

Every class loaded in Java has an instance of java.lang.Class. You can get the Class object using:

Class<?> clazz = Class.forName("java.util.ArrayList");

In Java, every class that is loaded into the Java Virtual Machine (JVM) has an associated object of type java.lang.Class. This object contains metadata about the class itself, such as its name, its fields, methods, and constructors. The Class.forName method allows you to retrieve the Class object for any class by providing the fully qualified name of the class as a string. In the example, we retrieve the Class object for java.util.ArrayList.

Think of the Class object as a detailed description in a library catalog. When you want to learn about a specific book (class), you look up its entry in the catalog. Class.forName is like searching for that specific entry using the book's title, allowing you to access all the details you need.

You can access the following class metadata:

• Fields using getFields() or getDeclaredFields()
• Methods using getMethods() or getDeclaredMethods()
• Constructors using getConstructors() or getDeclaredConstructors()
• Superclass and interfaces

Example:

for (Method m : clazz.getDeclaredMethods()) {
    System.out.println(m.getName());
}

Reflection in Java provides methods to inspect various members of a class. You can retrieve fields, methods, and constructors using specific methods like getFields(), getDeclaredFields(), getMethods(), and so on. getDeclaredMethods() retrieves all methods defined in the class (including private ones). The provided example shows how to loop through all declared methods in the class and print their names.

Imagine looking through a toolbox that contains all the tools (class members) you need for your project. Each tool has a specific use, and with reflection, you can inspect which tools are available, their types, and their functionalities without opening the toolbox. The getDeclaredMethods() is like checking the labels on the toolbox's compartment, telling you what each tool (method) is.

Create objects dynamically:

Object obj = clazz.getDeclaredConstructor().newInstance();

Using reflection, you can create new instances of classes dynamically at runtime. The method getDeclaredConstructor() retrieves a constructor of the class, and newInstance() is then called to create a new object. This is particularly useful when the class type is not known at compile time.

Think of this as ordering a custom-made cake for a party. You don't specify the exact details in advance but rather just tell the baker the kind of cake you want when the event arrives. In programming, when creating an object dynamically, you specify the class at runtime, similar to how you give the baker your cake preferences when needed.

Reflection allows access to private members using setAccessible(true):

Field field = clazz.getDeclaredField("privateField");
field.setAccessible(true);
field.set(obj, 123);

Java's reflection mechanism provides the ability to access private members of a class, which are usually not accessible from outside the class. By using setAccessible(true), you bypass the default access checks. In this example, a field named privateField is accessed and modified with the value 123. This capability is powerful but should be used sparingly due to security implications.

Imagine having a friend who works at a secretive club. Typically, the club's main entrance (private member) is not accessible to just anyone. However, your friend gives you a VIP pass (setAccessible(true)) allowing you to enter and interact with areas usually off-limits. In programming, this means modifying properties that are normally hidden from other classes.

--