feat: add WrapperDemo3 to demonstrate Character and Boolean wrapper class behavior

WHAT was added:
- Example with `Character` wrapper:
  - Conversion from lowercase to uppercase using `Character.toUpperCase()`.
  - Conversion of `Character` to `String` using `Character.toString()`.
- Notes on immutability of wrapper classes (Character, Boolean, etc.).

KEY LEARNINGS:
1. Immutability of Wrappers:
   - Wrapper classes in Java (`Character`, `Boolean`, `Integer`, etc.) are immutable.
   - Any transformation method (e.g., `toUpperCase`) does NOT modify the existing object;
     instead, it returns a new value.
   - Example:
     ```java
     Character a1 = 'a';
     Character.toUpperCase(a1); // returns 'A' but doesn't change a1
     a1 = Character.toUpperCase(a1); // must assign back
     ```

2. Character Class Usage:
   - `Character.toUpperCase('a') → 'A'`
   - `Character.toString('A') → "A"` (String object)
   - Shows how wrapper methods provide utility functions for conversions.

3. Boolean Wrapper Insights:
   - Boolean is also immutable.
   - Examples (not shown in code but relevant):
     - `Boolean.valueOf("true")` → `true`
     - `Boolean.parseBoolean("false")` → `false`
   - Useful for parsing string inputs into boolean values.

REAL-WORLD APPLICATIONS:
- ✅ Text processing: Converting user input to uppercase/lowercase before validation.
- ✅ Data validation: Converting character/boolean values safely in web forms or config files.
- ✅ String formatting: Wrapper methods help ensure proper case transformations in reporting tools.
- ✅ Immutable behavior: Prevents accidental side effects in multi-threaded systems.

RULE OF THUMB:
- Always capture the returned value from wrapper utility methods.
- Wrapper classes = immutable; they behave like `String` in Java.

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

Author: Someshdiwan

Section20JAVA.lang.Package/src/WrapperDemo3.java

@@ -1,8 +1,9 @@
 public class WrapperDemo3 {
     public static void main(String[] args) {
-        //Character Class
+        //Character Class.
         Character a1='a';
         a1 = Character.toUpperCase(a1);
+
         System.out.println(a1);
 
         String str = Character.toString(a1);
@@ -14,9 +15,7 @@ public static void main(String[] args) {
         System.out.println(a1);
 
         Why doesn't a1 change?
-
         Immutability: The Character class is immutable, meaning its value cannot be changed once assigned.
-
         Return Value Not Used: Character.toUpperCase(a1) returns a new character ('A') but does not modify a1 in place.
 
         How to Fix It?
@@ -29,10 +28,29 @@ You need to store the returned value from toUpperCase(a1),like this:
         Similarly, Character.toString(a1) returns a String representation of a1, but does not modify a1.
         */
 
-        //Boolean Class
+        //Boolean Class.
         Boolean b;
-
-        //Boolean.
-
     }
 }
+
+/*
+1. Character Wrapper Class immutable hai → ek baar object ban gaya to uski value
+   change nahi hoti. Har method naya value return karega.
+
+2. Example: Character.toUpperCase('a') → 'A' return karega,
+   lekin original variable tabhi update hoga jab tum explicitly
+   usse assign karoge:
+   a1 = Character.toUpperCase(a1);
+
+3. Character.toString(a1) → ek String banata hai (original Character ko
+   modify nahi karta).
+
+4. Boolean Wrapper Class bhi immutable hai.
+   - Boolean.valueOf("true") → String ko Boolean object me convert karega.
+   - print karne pe directly "true" ya "false" dikhata hai.
+
+5. Rule of Thumb:
+   - Wrapper classes (Integer, Character, Boolean, etc.) sab immutable hote hain.
+   - Har operation me naya object return hota hai,
+     original variable change nahi hota jab tak tum explicitly assign na karo.
+*/