Reflection is a concept used in computer programming that allows a program to inspect, analyze, and modify its own structure and behavior at runtime. It provides the ability to examine metadata about objects, classes, methods, and properties, and to dynamically invoke methods or access fields and properties.

1. Inspection: Examine the properties, methods, and events of objects and types at runtime.
   - Example: Getting the list of methods or properties of a class.

2. Dynamic Invocation: Invoke methods or access fields and properties on objects dynamically, without knowing their names at compile time.
   - Example: Calling a method by its name stored in a string variable.

3. Type Discovery: Determine the type of an object at runtime.
   - Example: Checking the type of an object to decide how to process it.

4. Late Binding: Create instances of types and invoke methods without knowing the type at compile time.
   - Example: Creating an instance of a class by its name stored in a configuration file.

Type type = typeof(MyClass);
MethodInfo method = type.GetMethod("MyMethod");
method.Invoke(instance, null);

Class<?> clazz = MyClass.class;
Method method = clazz.getMethod("myMethod");
method.invoke(instance);

method = getattr(obj, 'method_name')
method()

- Flexibility: Allows programs to be more flexible and dynamic.
- Metadata Access: Enables access to metadata information about types and members.
- Dynamic Behavior: Facilitates dynamic behavior, such as invoking methods or accessing properties based on runtime information.

- Performance Overhead: Reflection can be slower than direct code execution because it involves additional processing.
- Complexity: Can make code harder to understand and maintain.
- Security Risks: May expose private members and methods, potentially leading to security vulnerabilities.

In summary, reflection is a powerful tool for dynamic programming and introspection, enabling programs to interact with their own structure and behavior in a flexible and dynamic way.