feat: add demo for Wrapper Classes and Autoboxing/Unboxing in Java

WHAT was added:
- Example `WrapperClassesDemo` showcasing:
  - Conversion of primitive types (`char`, `boolean`, `int`, `double`) into wrapper objects (`Character`, `Boolean`, `Integer`, `Double`).
  - Printing wrapper objects directly (they auto-display their contained values).
  - Usage of `Long` and `Float` wrapper objects and converting them back into primitives (`long`, `float`).

WHY this matters:
- Demonstrates how wrapper classes act as object representations of primitive types.
- Shows both **autoboxing** (primitive → wrapper) and **unboxing** (wrapper → primitive).
- Highlights the flexibility of wrappers in allowing primitives to interact with Java Collections and APIs that require objects.

KEY TAKEAWAYS:
- Wrapper classes (Integer, Double, Boolean, Character, etc.) provide object versions of primitives.
- Autoboxing: Java automatically converts a primitive to its wrapper when needed.
  Example: `int x = 5; Integer y = x;`
- Unboxing: Java automatically converts wrapper back to primitive.
  Example: `Integer y = 10; int x = y;`
- Wrappers allow primitives to:
  - Be stored in generic collections (`List<Integer>`).
  - Use utility methods (`Integer.parseInt`, `Double.isNaN`, etc.).
  - Handle `null` values (primitives cannot be `null`).

REAL-WORLD APPLICATIONS:
- ✅ Working with collections (`List<Integer>`, `Map<Character, Boolean>`).
- ✅ Parsing and converting numeric/string inputs (`Integer.parseInt("123")`).
- ✅ Supporting nullability in APIs (e.g., database frameworks may return `null` wrappers).
- ✅ Using built-in utilities for number conversion, formatting, or bit manipulation.

PERFORMANCE NOTE:
- Wrappers add slight overhead compared to primitives due to object allocation.
- Prefer primitives in performance-critical code; use wrappers when interacting with APIs, collections, or when null values are necessary.

RULE OF THUMB:
- Primitives → raw performance, no null.
- Wrappers → flexibility, nullability, and API/Collections compatibility.

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

Author: Someshdiwan

Section20JAVA.lang.Package/src/WrapperClassesDemo.java

@@ -1,30 +1,61 @@
-public class WrapperClassesDemo
-{
-    public static void main(String[] args)
-    {
-        //Some primitive types
+public class WrapperClassesDemo {
+    public static void main(String[] args) {
+        // Primitive data types
         char letter = 'A';
         boolean value = true;
         int intNum = -269;
-        double floatNum = Math.pow(2,2); // 2 to the 2 is 4
+        double floatNum = Math.pow(2, 2); // 2^2 = 4.0
 
-        //Converting them into objects via their wrapper classes
-        Character Letter = (Character) letter;
-        Boolean Value = (Boolean) value;
-        Integer IntNum = (Integer) intNum;
-        Double FloatNum = (Double) floatNum;
+        // Autoboxing: Primitive → Wrapper Objects
+        Character Letter = letter;   // (Character.valueOf(letter))
+        Boolean Value = value;       // (Boolean.valueOf(value))
+        Integer IntNum = intNum;     // (Integer.valueOf(intNum))
+        Double FloatNum = floatNum;  // (Double.valueOf(floatNum))
 
-        //Wrapper objects print their value just fine
-        System.out.println("" + Letter + " " + Value + " " + IntNum + " " + FloatNum);
+        // Wrapper objects print their stored values
+        System.out.println(Letter + " " + Value + " " + IntNum + " " + FloatNum);
 
-        //Some Numerical objects
+        // More wrapper objects
         Long Num1 = 987L;
         Float Num2 = 34.56f;
 
-        //Turning them into primitive types
-        long num1 = (long) Num1;
-        float num2 = (float) Num2;
+        // Unboxing: Wrapper → Primitive
+        long num1 = Num1;   // (Num1.longValue())
+        float num2 = Num2;  // (Num2.floatValue())
 
-        System.out.println("" + num1 + " " + num2);
+        System.out.println(num1 + " " + num2);
     }
-}
+}
+
+/*
+1. Autoboxing & Unboxing:
+   - Primitive → Wrapper automatically ho jaata hai.
+     Example: int x = 5; Integer y = x; // Autoboxing
+   - Wrapper → Primitive bhi automatic hota hai.
+     Example: Integer obj = 10; int z = obj; // Unboxing
+
+2. Wrapper Classes ka kaam:
+   - Primitive types ko Objects ki tarah treat karne ke liye use hote hain.
+   - Useful in Collections (ArrayList<int> allow nahi hai, but ArrayList<Integer> chalega).
+
+3. Common methods:
+   - Integer.valueOf(String, radix) → String ko given base (radix) se integer me convert karta hai.
+     Example:
+       "11111" base 2 → 31 decimal
+       "A7" base 15 → decimal 157
+   - Integer.parseInt("1234") → String ko int me convert karta hai.
+
+4. Special methods:
+   - Integer.bitCount(n) → n ke binary representation me kitne 1-bits hai (population count).
+   - Integer.reverseBytes(x) → Byte order reverse kar deta hai (endianness swap).
+   - Integer.toBinaryString(40) → 40 ko binary string "101000" me convert karega.
+
+5. equals() vs == :
+   - equals() → object ke values compare karta hai.
+   - == → reference (memory address) compare karta hai.
+   - Wrapper classes me confusion ho sakta hai (Integer caching effect ke wajah se).
+
+6. Performance Note:
+   - Wrapper classes thread-safe nahi hote, sirf object wrappers hote hain.
+   - Autoboxing zyada use karne se performance cost ho sakti hai (boxing/unboxing overhead).
+*/