The Java Reflection API provides powerful capabilities, primarily in two key areas:

1. Bypassing Access Modifiers: Reflection allows access to private fields, methods, and constructors. While this is rarely used in application development, it's a common technique in frameworks and libraries for introspection and manipulation.
2. Dynamic Object Creation and Method Invocation: By integrating with configuration files or external data, reflection enables the dynamic instantiation of objects and the invocation of their methods at runtime, offering great flexibility.

Obtaining the Class Object

There are three primary ways to obtain a Class object representing a Java class:

• Class.forName(String className): This is the most common method, requiring the fully qualified name of the class.

Class<?> dynamicClass = Class.forName("com.example.MyClass");

• .class literal: You can directly access the Class object using the .class suffix on the class name.

Class<?> studentClass = Student.class;

• Object.getClass(): If you have an instance of a object, you can retrieve its Class object using the getClass() method.

Student studentInstance = new Student();
Class<?> instanceClass = studentInstance.getClass();

Working with Constructors

The java.lang.reflect.Constructor class provides methods to interact with class constructors. Key methods include:

When dealing with private constructors, you must temporarily change their accessibility using setAccessible(true).

To get a specific constructor, you pass the parameter types as an array of Class objects:

Constructor<?> constructor = clazz.getDeclaredConstructor(String.class, int.class);

You can inspect constructor modifiers and parameters:

// Get constructor modifiers
int modifiers = constructor.getModifiers();

// Get constructor parameters
Parameter[] parameters = constructor.getParameters();

Instantiating Objects via Constructors

The newInstance() method of the Constructor class is used to create object instances.

// 1. Get the Class object
Class<?> clazz = Class.forName("com.example.Student");

// 2. Get constructors
Constructor<?> constructor1 = clazz.getDeclaredConstructor(String.class);
Constructor<?> constructor2 = clazz.getDeclaredConstructor(String.class, int.class);

// 3. Instantiate objects
Student student1 = (Student) constructor1.newInstance("Alice");
System.out.println(student1);

// 3. Instantiate using a private constructor (requires setAccessible)
constructor2.setAccessible(true); // Enable access to private constructor
Student student2 = (Student) constructor2.newInstance("Bob", 25);
System.out.println(student2);

Accessing Fields

The java.lang.reflect.Field class represents class fields. Available methods for retrieving fields are:

You can retrieve a specific field using its name:

Field nameField = clazz.getDeclaredField("name");

Getting and Setting Field Values

The Field class provides methods to get and set the values of fields:

// 1. Get the Class object
Class<?> studentClazz = Class.forName("com.example.Student");

// 2. Get a specific field
Field nameField = studentClazz.getDeclaredField("name");

// Create a Student object
Student student = new Student("Charlie", 30);

// Obtain the field's current value
// Note: nameField.get(student) returns an Object, requiring a cast
String currentName = (String) nameField.get(student);
System.out.println("Current name: " + currentName);

// Modify the field's value
// Accessing private fields requires setAccessible(true)
nameField.setAccessible(true);
nameField.set(student, "David");

// Create another object instance for demonstration
Object genericObj = studentClazz.getDeclaredConstructor().newInstance();
nameField.set(genericObj, "Eve");

System.out.println("Updated student: " + student);
System.out.println("Generic object: " + genericObj);

// Expected output might look like:
// Current name: Charlie
// Updated student: Student{name='David', age=30}
// Generic object: Student{name='Eve', age=0}

You can also retrieve field modifiers, names, and data types:

// 1. Get the Class object
Class<?> studentClazz = Class.forName("com.example.Student");

// 2. Get a specific field
Field nameField = studentClazz.getDeclaredField("name");

// Get field modifiers
int modifiers = nameField.getModifiers();
System.out.println("Modifiers: " + modifiers);

// Get field name
String fieldName = nameField.getName();
System.out.println("Name: " + fieldName);

// Get field type
Class<?> fieldType = nameField.getType();
System.out.println("Type: " + fieldType);

Accessing Methods

The java.lang.reflect.Method class represents class methods. Methods for accessing methods include:

You can get all declared methods or a specific one, providing paramter types to handle overloaded methods:

Method[] allMethods = clazz.getDeclaredMethods();

// Get a specific method, e.g., "eat" that takes a String
Method eatMethod = clazz.getMethod("eat", String.class);

Invoking Methods

The invoke(Object obj, Object... args) method of the Method class executes a method.

• obj: The object on which to invoke the method.
• args: The arguments to pass to the method.

The return value of invoke is the method's return value, or null if the method returns void.

// 1. Get the Class object
Class<?> studentClazz = Class.forName("com.example.Student");

// 2. Create an instance of the class to invoke methods on
Object studentObj = studentClazz.getDeclaredConstructor().newInstance();

// 3. Get the specific method to invoke
Method eatMethod = studentClazz.getMethod("eat", String.class);

// Invoke the method
// The first argument is the object instance, the second is the method argument
Object result = eatMethod.invoke(studentObj, "Noodles");

// If the method returns a value, cast it appropriately
String mealDescription = (String) result;
System.out.println(mealDescription);

// Example for a method without parameters and no return value
Method studyMethod = studentClazz.getMethod("study");
studyMethod.invoke(studentObj); // No result to capture