feat(WeakReferenceDemo): add demo of WeakReference behavior and GC collection

What
- Added `WeakReferenceDemo` class.
- Created `Phone` object with a strong reference.
- Wrapped object in a `WeakReference<Phone>`.
- Printed object before and after nullifying strong reference and invoking GC.

Why
- To demonstrate how weak references behave in Java.
- Show that weak references do not prevent GC from reclaiming an object.
- Illustrate memory-sensitive referencing useful for caches and temporary objects.

How
- Step 1: Create strong reference `phone` → new Phone("Apple", "16 Pro").
- Step 2: Wrap in WeakReference (`phoneWeakReference`).
- Step 3: Print value via weak reference before GC.
- Step 4: Nullify strong reference (`phone = null`).
- Step 5: Call `System.gc()` and wait briefly.
- Step 6: Print value via weak reference again (likely null).

Logic
- Inputs:
  - Phone constructor with brand and model.
- Outputs:
  - Console log showing object before GC.
  - Console log showing null after GC (if collected).
- Flow:
  1. Strong + weak references exist.
  2. Strong reference nulled → only weak reference remains.
  3. GC may reclaim object and clear weak reference.
  4. `get()` returns null when object collected.
- Constraints:
  - GC timing is not deterministic; output may vary.
- Complexity:
  - O(1) for WeakReference operations.

Real-life applications
- Weak references prevent memory leaks in caches, maps, and listeners.
- Commonly used in `WeakHashMap`.
- Useful when objects should be reclaimed automatically under memory pressure.

Notes
- Strong references prevent GC, weak references do not.
- WeakReference `.get()` may return null anytime after GC.
- Demonstrates difference between strong and weak references clearly.

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

Author: Someshdiwan

Section 25 Collections Frameworks/Map Interface/Garbage Collection/src/WeakReferenceDemo.java

@@ -0,0 +1,34 @@
+import java.lang.ref.WeakReference;
+
+public class WeakReferenceDemo {
+    public static void main(String[] args) {
+        // Create a strong reference to a Phone object.
+        Phone phone = new Phone("Apple", "16 Pro");
+
+        // Wrap the Phone object inside a WeakReference.
+        WeakReference<Phone> phoneWeakReference = new WeakReference<>(phone);
+
+        // At this point:
+        // strong reference -> 'phone'
+        // weak reference   -> 'phoneWeakReference'
+        System.out.println("Before GC: " + phoneWeakReference.get());
+
+        // Remove the strong reference. Now only weak reference exists.
+        phone = null;
+
+        // Request Garbage Collection.
+        System.gc();
+
+        try {
+            Thread.sleep(3000); // Give GC time to run.
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        // WeakReference may have been cleared by GC.
+        System.out.println("After GC: " + phoneWeakReference.get());
+    }
+}
+
+// Demonstrates how weak references work in Java using WeakReference.
+// Weak references do not prevent an object from being garbage collected.