7.2.4. Using Reflection to Inspect a Class

public class Sample {
private int id;
public String name;
public void display() {
System.out.println("Display");
}
}

In this chunk, we define a simple Java class called 'Sample' with three members: a private integer 'id', a public string 'name', and a public method 'display()'. This class serves as a base for demonstrating the power of reflection, which allows us to inspect the properties and methods of this class at runtime, even if they are private.

Think of this class as an employee in a company. The 'id' number is a confidential record (private), while the 'name' is displayed publicly (public). Just like how you can ask a manager about an employee's job responsibilities (methods) without directly accessing their personal files (private fields).

Class<?> clazz = Sample.class;
System.out.println("Fields:");
for (Field field : clazz.getDeclaredFields()) {
System.out.println(field.getName());
}
System.out.println("Methods:");
for (Method method : clazz.getDeclaredMethods()) {
System.out.println(method.getName());
}

Here, we use reflection to obtain information about the 'Sample' class. We get a Class object for 'Sample' and then use getDeclaredFields() to list all its fields and getDeclaredMethods() to list all its methods. The output would show us 'id', 'name', and 'display' as the fields and methods of the class, giving us the ability to inspect data types and behaviors within the class.

Imagine you are a librarian (using reflection) who wants to know about a specific book (class). You can look inside to see what chapters (fields) it has and what actions (methods) you can perform with it, even if you can't open the book to read every detail.

Class<?> clazz = Class.forName("Sample");
Object obj = clazz.getDeclaredConstructor().newInstance();

In this chunk, we demonstrate how to create an instance of the 'Sample' class dynamically at runtime using reflection. We use Class.forName() to get the Class object, and then getDeclaredConstructor().newInstance() to create a new object of that class. This shows the power of reflection by allowing object creation without knowing the class directly at compile time.

Consider this like a chef who can prepare any dish (create instances) without having the recipe book (class definition) at hand. The chef can choose what to cook (create an object) based on the ingredients available (class name) and prepare it right there in the kitchen (runtime).

Field field = clazz.getDeclaredField("id");
field.setAccessible(true);
field.set(obj, 101);
System.out.println(field.get(obj));

This chunk discusses how reflection can be used to access private members of a class. By utilizing getDeclaredField(), we can access the private field 'id' from the 'Sample' class. We then use setAccessible(true) to bypass access checks and change the value of 'id' to 101, before printing the new value. This ability should be used cautiously as it breaks encapsulation principles.

Imagine you have a safe (the private field) where a secret (id) is stored. Normally, you can’t open it without permission. However, if you had the right tools (reflection), you could bypass the lock (setAccessible) and change the contents of the safe without the owner's knowledge, which may not always be the right thing to do.

public class Processor {
@MyAnnotation(value = "run")
public void execute() {
System.out.println("Executing...");
}
}

Processor:
```Java
Class<?> clazz = Processor.class;
for (Method method : clazz.getDeclaredMethods()) {
if (method.isAnnotationPresent(MyAnnotation.class)) {
MyAnnotation anno = method.getAnnotation(MyAnnotation.class);
System.out.println("Annotation value: " + anno.value());
method.invoke(clazz.getDeclaredConstructor().newInstance());
}
}

In this final chunk, we show how reflection can be used to process annotations. The 'Processor' class contains a method 'execute' annotated with '@MyAnnotation'. Using reflection, we check for the presence of this annotation, retrieve its value, and then invoke the method. This illustrates how annotations can drive execution behavior in a program dynamically.

Think of annotations as special instructions or notes left by a programmer. It's like a chef (the method) who has a note (the annotation) that tells them to follow a specific recipe step in a cooking competition. Using reflection is like the judges looking at those notes to see what the chef is supposed to do next and ensure they follow the rules.

--