feat(generics): implement Box<T extends Number> class with bounded type parameter

WHAT:
- Created a generic class `Box<T>` that accepts only subclasses of `Number` (e.g., Integer, Double, Float).
- Added constructor for initialization, along with getter and setter methods.

WHY:
- Demonstrates **bounded type parameters** in Java Generics.
- Restricts generic types to numeric classes, preventing invalid usages (e.g., Box<String> is not allowed).
- Ensures type safety while allowing flexibility with different numeric types.

HOW:
- Declared class as `Box<T extends Number>`.
- Provided constructor `Box(T value)` to initialize the box with a numeric type.
- Implemented `getValue()` and `setValue(T value)` for retrieving and modifying the stored value.

KEY POINTS:
- `T extends Number` means:
  - `T` can be `Integer`, `Double`, `Float`, `Long`, etc. (all subclasses of `Number`).
  - Enforces compile-time restriction → avoids misuse with non-numeric types.
- Without this bound, `Box<T>` would accept any type (including non-numeric ones).

BENEFITS:
- Enables safe numeric operations (e.g., `doubleValue()`, `intValue()`) since `Number` defines these methods.
- Prevents runtime errors by catching invalid type usage at compile-time.
- Makes the class reusable for different numeric scenarios (statistics, math utilities, etc.).

REAL-WORLD USE CASES:
- Generic mathematical containers that must only store numbers.
- Utility classes in frameworks dealing with measurements, coordinates, or statistics.
- Similar to how `java.util.Optional<T>` restricts null-handling, this restricts type usage.

EXAMPLE USAGE:
Box<Integer> intBox = new Box<>(10);
Box<Double> doubleBox = new Box<>(15.5);

System.out.println(intBox.getValue());    // 10
System.out.println(doubleBox.getValue()); // 15.5

// Box<String> strBox = new Box<>("Hello"); // Compile-time error

NOTES:
• Upper bounds (extends) are used for reading numeric values.
• Lower bounds (super) are used when we want to write values safely.

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

Author: Someshdiwan

Section24JavaGenerics/src/GenericConstructors/Box.java

@@ -0,0 +1,48 @@
+package GenericConstructors;
+
+public class Box<T extends Number> {
+    private T value;
+
+    public Box(T value) {
+        this.value = value;
+    }
+
+    public T getValue() {
+        return value;
+    }
+
+    public void setValue(T value) {
+        this.value  = value;
+    }
+}
+
+/*
+1. Generic Class with Constructor:
+   - Class `Box<T extends Number>` ek bounded generic class hai.
+   - Yaha `T` sirf `Number` class ya uske subclasses (Integer, Float, Double, Long, etc.) hi ho sakte hain.
+   - Ab constructor me `Box(T value)` banaya gaya hai jo object create karte waqt initial value set karega.
+
+2. Example Usage:
+   Box<Integer> intBox = new Box<>(10);   //Allowed
+   Box<Double> doubleBox = new Box<>(20.5); //Allowed
+   Box<String> strBox = new Box<>("Hello"); //Error (String is not a Number)
+
+3. Methods:
+   - `getValue()` → box ke andar jo value hai usko return karta hai.
+   - `setValue(T value)` → box ke andar naya value set karne deta hai.
+
+4. Benefits of Bounded Generics with Constructor:
+   - Type safety → sirf numeric types hi box me store honge.
+   - Compile-time error detection → agar galat type pass karoge (jaise String) toh compiler turant error dega.
+   - Code reusability → ek hi class alag-alag numeric types (Integer, Float, Double) ke liye use ho sakti hai.
+
+5. Why Constructor is Important?
+   - Jab a tum object create karte ho, turant ek value assign kar sakte ho.
+   - Example:
+       Box<Integer> b1 = new Box<>(100);
+       System.out.println(b1.getValue()); // Output: 100
+
+✔ `T extends Number` → Sirf numeric subclasses allowed.
+✔ Constructor `Box(T value)` → initialization ke time value set karta hai.
+✔ Safe, reusable aur strongly typed container ban jata hai numeric values ke liye.
+*/