feat: demonstrate Reflection API usage to inspect class structure at runtime

WHAT was added:
- Implemented a `Refelectionpackage` program showcasing how to use Java Reflection API (`java.lang.reflect.*`).
- Created a sample class `My` with fields (private, protected, default, public), constructors, and methods.
- Demonstrated retrieval of:
  - Class metadata via `My.class`
  - Fields using `getDeclaredFields()`
  - Public methods (including inherited ones) using `getMethods()`
  - Constructors using `getConstructors()`
  - Method parameters using `getParameters()`

WHY this matters:
- Reflection enables inspection and manipulation of classes at runtime without knowing their structure at compile time.
- Essential for building frameworks, libraries, debuggers, and tools that require dynamic behavior.

KEY FEATURES SHOWN:
1. **Access Class Information**
   - `Class c = My.class;`
   - Alternative: `obj.getClass()`

2. **Inspect Fields**
   - `getDeclaredFields()` → returns all fields regardless of modifier (public, private, protected, package).
   - Useful for serialization/deserialization libraries.

3. **Inspect Methods**
   - `getMethods()` → returns all public methods, including those inherited from `Object`.
   - Example: toString(), hashCode(), equals() also appear.

4. **Inspect Constructors**
   - `getConstructors()` → returns all public constructors.
   - Output for `My`:
     ```
     public My()
     public My(int,int)
     ```

5. **Inspect Parameters**
   - `getParameters()` → retrieves metadata about method parameters.
   - Useful for frameworks that need to auto-bind request parameters to method arguments.

6. **Security & Performance Considerations**
   - Reflection bypasses normal access control (can access private members with `setAccessible(true)`).
   - Slower than direct calls due to runtime type checks.
   - Should be used carefully in performance-critical or secure applications.

REAL-WORLD APPLICATIONS:
- **Frameworks (Spring, Hibernate):** Dependency injection, ORM entity mapping, dynamic proxies.
- **Testing (JUnit, TestNG):** Auto-discovery and invocation of test methods via annotations.
- **IDE/Debugger Tools:** Inspect and modify objects at runtime.
- **Serialization Libraries (Jackson, Gson):** Dynamically map JSON/XML fields to Java objects.
- **Dependency Injection Containers:** Instantiate and configure beans without explicit `new`.

KEYWORDS:
Reflection, Class metadata, Fields, Methods, Constructors, Parameters, Java Introspection.

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

Author: Someshdiwan

Section20JAVA.lang.Package/src/Refelectionpackage.java

@@ -1,9 +1,13 @@
-//https://www.geeksforgeeks.org/reflection-in-java/
-
 import java.lang.reflect.*;
 
-class My
-{
+/**
+ * 📘 GeeksforGeeks – Reflection in Java
+ * <p>
+ * Article: <a href="https://www.geeksforgeeks.org/reflection-in-java/">
+ * https://www.geeksforgeeks.org/reflection-in-java/</a>
+ */
+
+class My {
     private int a;
     protected int b;
     public int c;
@@ -15,17 +19,14 @@ public My(int x,int y) {}
 
     public void display(String s1,String s2) {}
     public int show(int x,int y) {return 0;}
-
 }
 
-public class Refelectionpackage
-{
-    public static void main(String[] args)
-    {
-        Class c=My.class; //Getting defination by assign ing .class file
-        /* Or you also use
-        ReflectionJAVA m=new ReflectionJAVA();
-        Class c1=m.getClass();
+public class Refelectionpackage {
+    public static void main(String[] args) {
+        Class c=My.class;
+        /* Getting definition by assigning .class file.
+
+        Or you also use, ReflectionJAVA m=new ReflectionJAVA(); Class c1=m.getClass();
         */
         System.out.println(c.getName());
 
@@ -36,21 +37,37 @@ public static void main(String[] args)
         for(Method m:meth)
             System.out.println(m);
 
-        //Getting a detail of the constructer in class.
+        //Getting a detail of the constructor in class.
+
         Constructor con[] = c.getConstructors();
+
         for(Constructor ct:con)
             System.out.println(ct);
-
         /*
         O/p:
         public My()
         public My(int,int)
         */
 
         Parameter param[]=meth[0].getParameters();
-        for(Parameter p:param)
-        {
+        for(Parameter p:param) {
             System.out.println(p);
         }
     }
-}
+}
+
+/*
+1. Reflection ek a runtime mechanism hai → Jisme hum classes, methods, fields, constructors ki info access kar sakte hain.
+2. Entry point: `Class` object (Class c = My.class; ya obj.getClass()).
+3. `getDeclaredFields()` → sabhi fields (private + protected + default + public).
+4. `getMethods()` → sirf public methods (including inherited from Object class like toString(), hashCode()).
+5. `getConstructors()` → sirf public constructors deta hai.
+6. `getParameters()` → ek method ke parameter list ka detail deta hai.
+
+7. Reflection ka use:
+   - Frameworks (Spring, Hibernate) → objects ko dynamically inspect aur manipulate karna.
+   - Tools (JUnit, debuggers) → runtime par methods ko call karna ya inject karna.
+8. Cons:
+   - Slow performance (direct call se slower).
+   - Security risks (private fields/methods access karne ki ability).
+*/