feat: add ReflectionJAVA program to list declared methods of a class at runtime

WHAT was added:
- Implemented `ReflectionJAVA` class demonstrating reflection with `Class.forName()`.
- Program accepts class name as a runtime argument (`args[0]`).
- Retrieves all declared methods using `getDeclaredMethods()`.
- Prints each method’s full signature (return type, name, parameters, modifiers).

WHY this matters:
- Shows how to dynamically inspect a class’s behavior at runtime without knowing its structure at compile time.
- Essential for building frameworks, tools, and debuggers that adapt to different classes dynamically.

KEY LEARNINGS DEMONSTRATED:
1. **Loading a class dynamically**
   - `Class.forName(args[0])` loads a class by its fully qualified name.
   - Example: `java.lang.String` as input loads the `String` class.

2. **Inspecting methods**
   - `getDeclaredMethods()` retrieves *all methods* declared in the class, regardless of access modifiers (public, private, protected, package).
   - Unlike `getMethods()`, it does not include inherited methods from superclasses.

3. **Method details**
   - Each method’s signature (return type, parameters, exceptions) is printed using `toString()`.
   - Example output for `java.lang.String`:
     ```
     public int java.lang.String.length()
     public boolean java.lang.String.isEmpty()
     public char java.lang.String.charAt(int)
     ...
     ```

4. **Exception handling**
   - Wraps reflection logic in a `try-catch` block to gracefully handle errors like `ClassNotFoundException` or security restrictions.

REAL-WORLD APPLICATIONS:
- **Testing frameworks** (JUnit, TestNG): Discover and execute annotated methods at runtime.
- **Dependency injection (Spring, Guice)**: Dynamically inspect constructors and methods for wiring dependencies.
- **ORM frameworks (Hibernate, JPA)**: Map class fields/methods to database columns and operations.
- **Debugging/Profiling tools**: Inspect objects and methods without modifying source code.
- **Dynamic plugin systems**: Load external classes and invoke methods without recompilation.

LIMITATIONS:
- Slower than direct method calls due to runtime inspection overhead.
- Can break encapsulation by accessing private methods/fields.
- Requires careful exception handling (checked exceptions like `ClassNotFoundException`, `IllegalAccessException`).

KEYWORDS:
Reflection API, Class.forName, getDeclaredMethods, runtime inspection, dynamic method discovery.

Signed-off-by: https://github.com/Someshdiwan <[email protected]>

Author: Someshdiwan

Section20JAVA.lang.Package/src/ReflectionJAVA.java

@@ -1,21 +1,42 @@
-/*
-Certainly! Reflection in Java is a powerful feature that allows you to inspect and manipulate classes, methods, and fields at runtime.
-This can be particularly useful for tasks like debugging, testing, or creating more flexible and dynamic applications.
-*/
 import java.lang.reflect.*;
 
-
 public class ReflectionJAVA {
-    public static void main(String args[])
-    {
+    public static void main(String args[]) {
         try {
             Class c = Class.forName(args[0]);
             Method m[] = c.getDeclaredMethods();
+
             for (int i = 0; i < m.length; i++)
                 System.out.println(m[i].toString());
         }
         catch (Throwable e) {
             System.err.println(e);
         }
     }
-}
+}
+
+/*
+Certainly! Reflection in Java is a powerful feature that allows you to inspect and manipulate classes, methods, and fields at runtime.
+This can be particularly useful for tasks like debugging, testing, or creating more flexible and dynamic applications.
+
+1. Command line se run karte waqt:
+   java ReflectionJAVA java.util.ArrayList
+   Ye ArrayList class ke saare declared methods print karega.
+
+2. `Class.forName("package.ClassName")`:
+   Dynamically load karta hai class ko runtime par.
+
+3. `getDeclaredMethods()`:
+   Sirf us class ke methods deta hai (private + protected + public).
+   Agar tum `getMethods()` use karoge to uske parent (Object class) ke bhi public methods show honge.
+
+4. Reflection ka use cases:
+   Debugging tools
+   Unit testing frameworks (JUnit)
+   Dependency Injection frameworks (Spring)
+   Serialization / Deserialization libraries (Jackson)
+
+5. Drawbacks:
+   Thoda slow hota hai (direct method call se zyada overhead).
+   Security risk hota hai agar private fields/methods ko expose kar diya jaye.
+*/