What is reflection in programming?

Reflection is a mechanism of the programming language that allows a program to obtain information about its structure and behavior at runtime. This includes the ability to introspect classes, methods, fields, and their attributes, as well as the ability to dynamically create objects, invoke methods, and get/set field values, even if the names of these elements are unknown at compile time.

Main features of reflection in Java:

• Getting a Class object: Represents a description of a class or interface. Obtained via Object.getClass(), .class syntax, or Class.forName().
• Getting information about class members:
  • getFields(), getDeclaredFields(): Getting information about fields.
  • getMethods(), getDeclaredMethods(): Getting information about methods.
  • getConstructors(), getDeclaredConstructors(): Getting information about constructors.
• Dynamically creating objects: Using Class.newInstance() (deprecated) or Constructor.newInstance().
• Dynamically invoking methods: Using Method.invoke().
• Dynamically managing fields: Using Field.get() and Field.set().
• Getting information about annotations: Methods like getAnnotations().

Advantages of reflection:

• Flexibility and dynamism: Allows creating extendable and configurable applications (e.g., frameworks, serialization/deserialization libraries, ORM).
• Testing: Can be used to access private class members when writing unit tests.
• Debugging: Allows inspecting object states at runtime.

Disadvantages of reflection:

• Performance: Calls via reflection are significantly slower than direct calls.
• Breaking encapsulation: Allows access to private members, which can make code maintenance difficult.
• Runtime errors: Errors related to reflection (e.g., ClassNotFoundException, NoSuchMethodException) are only detected at runtime, not at compile time.
• Code complexity: Code using reflection is often less readable and more complex to understand.

Example of usage (getting and invoking a private method):

// Example class with a private method
class MyClass {
    private String privateMethod(String param) {
        return "Hello, " + param + "!";
    }
}

// Using reflection to invoke a private method
public class ReflectionExample {
    public static void main(String[] args) {
        try {
            MyClass obj = new MyClass();
            // Get Class object for MyClass
            Class<?> cls = obj.getClass();

            // Get Method object for the private method (specify name and parameter types)
            Method privateMethod = cls.getDeclaredMethod("privateMethod", String.class);

            // Make the method accessible (otherwise IllegalAccessException will occur)
            privateMethod.setAccessible(true);

            // Invoke the private method on object 'obj' with parameter "world"
            Object result = privateMethod.invoke(obj, "world");

            // Print the result
            System.out.println(result); // Outputs: Hello, world!

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

In Android development, reflection is often used by frameworks (e.g., Dagger, Gson, Room) for dependency injection, serialization/deserialization, and code generation. Developers should use reflection cautiously due to its disadvantages, preferring compile-time solutions when possible (e.g., annotation processors).