Explain the concept of reflection in Java and provide an example of how it can be used.

Reflection in Java is a powerful feature that allows a program to examine and manipulate its own structure at runtime. It provides a way to inspect classes, interfaces, fields, methods, and constructors dynamically, without having prior knowledge of their specific details. Reflection enables developers to introspect and modify the behavior of classes and objects, opening up possibilities for advanced meta-programming and framework development. Let's delve deeper into the concept of reflection and provide an example of how it can be used.

In Java, reflection is facilitated by the `java.lang.reflect` package, which provides classes and interfaces for accessing and manipulating the reflective information. Here are some key aspects of reflection:

1. Accessing Class Information:
Reflection allows you to obtain information about classes at runtime. You can retrieve details such as the class name, superclass, implemented interfaces, constructors, methods, and fields. This information can be useful for various purposes, including runtime analysis, debugging, and dynamic instantiation.
2. Creating New Instances:
Reflection enables you to create new instances of classes dynamically, even if you don't know their specific types at compile time. You can use the `newInstance()` method provided by the `java.lang.Class` class to instantiate objects based on their runtime class information.
3. Invoking Methods:
Reflection allows you to invoke methods dynamically on objects, including private and inaccessible methods. You can obtain a reference to a method using its name and parameter types, and then invoke it using the `invoke()` method provided by the `java.lang.reflect.Method` class. This capability is particularly useful in scenarios where the method to be invoked is determined at runtime.
4. Accessing and Modifying Fields:
Reflection provides the ability to access and modify the fields of an object, even if they are private or inaccessible from the calling code. You can retrieve the fields using the `getField()` or `getDeclaredField()` methods of the `java.lang.Class` class, and then use the `get()` and `set()` methods of the `java.lang.reflect.Field` class to read and modify their values.

Example Usage of Reflection:

Let's consider a scenario where you have a Java class `Person` with private fields `name` and `age`, and you want to access and modify these fields dynamically using reflection:

```
java`import java.lang.reflect.Field;

public class Person {
private String name;
private int age;

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

// Getters and setters omitted for brevity

public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
Person person = new Person("John Doe", 25);

// Accessing and modifying private fields using reflection
Class<Person> personClass = Person.class;
Field nameField = personClass.getDeclaredField("name");
Field ageField = personClass.getDeclaredField("age");

nameField.setAccessible(true);
ageField.setAccessible(true);

String nameValue = (String) nameField.get(person);
int ageValue = (int) ageField.get(person);

System.out.println("Name: " + nameValue);
System.out.println("Age: " + ageValue);

nameField.set(person, "Jane Smith");
ageField.setInt(person, 30);

System.out.println("Modified Name: " + person.getName());
System.out.println("Modified Age: " + person.getAge());
}
}`
```
In the above example, we use reflection to access and modify the private fields `name` and `age` of the `Person` object. By obtaining the field references using `getDeclaredField()`, setting their accessibility to `true`, and using `get()` and `set()` methods, we can read and modify the