10. Reflection in Java

📝 Reflection is a powerful feature in Java that allows you to inspect and manipulate classes, methods, fields, and other components at runtime, even if they are private or protected.

1. What is Reflection?

• Reflection enables Java programs to analyze themselves and dynamically access classes and methods.
• It is part of the java.lang.reflect package.

2. Benefits of Reflection

• Dynamic Behavior: Allows the implementation of dynamic behavior, such as loading classes at runtime or invoking methods dynamically.
• Access to Private Members: Can access private fields and methods, facilitating debugging and testing.
• Framework Development: Useful in building frameworks like Hibernate and Spring that require dynamic type inspection.

3. Key Classes in Reflection

• Class: Represents a class or interface in the Java runtime.
• Field: Represents a field (member variable) of a class.
• Method: Represents a method of a class.
• Constructor: Represents a constructor of a class.

4. Basic Reflection Example

Here’s how to use reflection to inspect a class:

Example:

class Person {
    private String name;
    public int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void displayInfo() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

// Reflection usage
public class ReflectionExample {
    public static void main(String[] args) throws Exception {
        // Get the Class object
        Class<?> personClass = Class.forName("Person");

        // Create an instance
        Object personInstance = personClass.getConstructor(String.class, int.class).newInstance("Alice", 30);

        // Access public method
        Method displayMethod = personClass.getMethod("displayInfo");
        displayMethod.invoke(personInstance);

        // Access private field
        Field nameField = personClass.getDeclaredField("name");
        nameField.setAccessible(true); // Allow access to private field
        System.out.println("Name (via reflection): " + nameField.get(personInstance));
    }
}

5. Accessing Fields

You can access both public and private fields using reflection.

Example:

Field ageField = personClass.getField("age"); // Public field
int ageValue = ageField.getInt(personInstance);
System.out.println("Age: " + ageValue);

6. Accessing Methods

You can invoke methods using reflection, regardless of their access modifiers.

Example:

Method method = personClass.getDeclaredMethod("getName"); // Private method
method.setAccessible(true); // Allow access to private method
String name = (String) method.invoke(personInstance);
System.out.println("Name: " + name);

7. Performance Considerations

While reflection is powerful, it comes with performance overhead:

• Reflection operations are slower than direct method calls.
• Excessive use of reflection can lead to code that is hard to understand and maintain.

8. Summary of Reflection

Feature	Description
Dynamic Class Inspection	Inspect classes, methods, and fields at runtime.
Access Modifiers	Can access private and protected members.
Key Classes	Class, Field, Method, Constructor.
Performance Overhead	Slower than direct access; use judiciously.
Use Cases	Framework development, debugging, and dynamic behavior.

Reflection is a powerful tool in Java for accessing and manipulating classes and their members at runtime.