Java Reflection is a powerful feature that enables programs too inspect and manipulate classes, methods, and fields at runtime. This capability is fundamental to many frameworks and is essential for dynamic programming scenarios. This guide explores the core concepts and practical applications of Java Reflection through detailed examples.

Core Concepts of Reflection

Reflection allows a running Java program to examine its own structure and the structure of other classes. It provides the ability to dynamically invoke methods and access fields of objects, even without prior knowledge of their clas definitions at compile time.

Obtaining Class Objects

Every class in Java has an associated Class object. There are three primary ways to obtain this object:

package com.example.reflection;

public class ClassObjectDemo {
    public static void main(String[] args) {
        // Method 1: Using the .class syntax
        Class<?> class1 = Sample.class;
        
        // Method 2: From an object instance
        Sample obj = new Sample();
        Class<?> class2 = obj.getClass();
        
        // Method 3: Using the fully qualified class name
        try {
            Class<?> class3 = Class.forName("com.example.reflection.Sample");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

class Sample {
    // Example class
}

Creating Objects via Reflection

Reflection can dynamically instantiate classes. Instances can be created using the Class object's newInstance method (deprecated in newer JDKs) or more robustly through Constructor objects.

package com.example.reflection;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class ObjectCreationDemo {
    public static void main(String[] args) {
        try {
            // Get the Class object
            Class<?> clazz = Class.forName("com.example.reflection.DataModel");
            
            // Create object using the no-argument constructor
            DataModel instance1 = (DataModel) clazz.getDeclaredConstructor().newInstance();
            
            // Create object using a specific constructor with a String parameter
            Constructor<?> constructor = clazz.getConstructor(String.class);
            DataModel instance2 = (DataModel) constructor.newInstance("Initialized via Reflection");
            
        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException |
                 NoSuchMethodException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

class DataModel {
    private String content;
    
    public DataModel() {
        this.content = "Default Value";
    }
    
    public DataModel(String content) {
        this.content = content;
    }
    
    public String getContent() {
        return content;
    }
}

Accessing and Modifying Fields

Reflection provides the ability to read and write the values of fields, including private ones, by using Field objects.

package com.example.reflection;

import java.lang.reflect.Field;

public class FieldAccessDemo {
    public static void main(String[] args) {
        try {
            Class<?> clazz = Class.forName("com.example.reflection.DataModel");
            DataModel obj = (DataModel) clazz.getDeclaredConstructor().newInstance();
            
            // Get the field named "content"
            Field field = clazz.getDeclaredField("content");
            
            // Override access restrictions
            field.setAccessible(true);
            
            // Read the current value
            String currentValue = (String) field.get(obj);
            System.out.println("Initial value: " + currentValue);
            
            // Modify the field's value
            field.set(obj, "Updated via Reflection API");
            System.out.println("New value: " + obj.getContent());
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class DataModel {
    private String content;
    
    public DataModel() {
        this.content = "Default Value";
    }
    
    public String getContent() {
        return content;
    }
}

Invoking Methods

Methods, including private ones, can be invoked dynamically using Method objects obtained through reflection.

package com.example.reflection;

import java.lang.reflect.Method;

public class MethodInvocationDemo {
    public static void main(String[] args) {
        try {
            Class<?> clazz = Class.forName("com.example.reflection.Utility");
            Utility util = (Utility) clazz.getDeclaredConstructor().newInstance();
            
            // Get the private method named "internalProcess"
            Method method = clazz.getDeclaredMethod("internalProcess");
            
            // Allow access to the private method
            method.setAccessible(true);
            
            // Invoke the method on the object
            method.invoke(util);
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class Utility {
    private void internalProcess() {
        System.out.println("Private method executed through reflection.");
    }
}

Retrieving Class Metadata

Reflection can be used to introspect a class's structure, listing its fields, methods, and constructors.

package com.example.reflection;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class MetadataInspectionDemo {
    public static void main(String[] args) {
        try {
            Class<?> clazz = Class.forName("com.example.reflection.CompleteModel");
            
            // Get all declared fields
            Field[] fields = clazz.getDeclaredFields();
            System.out.println("Fields:");
            for (Field f : fields) {
                System.out.println("  " + f.getName());
            }
            
            // Get all declared methods
            Method[] methods = clazz.getDeclaredMethods();
            System.out.println("\nMethods:");
            for (Method m : methods) {
                System.out.println("  " + m.getName());
            }
            
            // Get all declared constructors
            Constructor<?>[] constructors = clazz.getDeclaredConstructors();
            System.out.println("\nConstructors:");
            for (Constructor<?> c : constructors) {
                System.out.println("  " + c.getName());
            }
            
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

class CompleteModel {
    private String data;
    private int count;
    
    public CompleteModel() {
        this.data = "empty";
        this.count = 0;
    }
    
    public CompleteModel(String data, int count) {
        this.data = data;
        this.count = count;
    }
    
    private void reset() {
        this.count = 0;
    }
    
    public String getData() {
        return data;
    }
    
    public void setData(String data) {
        this.data = data;
    }
}

Through reflection, developers can fully explore a class's architecture, enabling advanced runtime analysis and manipulation.