feat(generics): add Box2 class with generic constructor using <T extends Number>

WHAT:
- Implemented `Box2` class with a generic constructor instead of a generic class.
- Constructor `<T extends Number> Box2(T value)` allows initialization with any subclass of `Number`.
- Stored the value in a `Number` field for retrieval.

WHY:
- Demonstrates the concept of **generic constructors** in Java.
- Shows that generics can be applied not only at the class level but also at the constructor level.
- Useful when you want flexibility in object creation without making the whole class generic.

HOW:
- Defined a generic constructor `<T extends Number> Box2(T value)`.
- Stored the passed value in a `Number` type field.
- Added `getValue()` method to retrieve the stored number.
- In `main()`, created examples using `Integer` and `Double`.

KEY POINTS:
- The **class itself is not generic**, only the constructor is.
- This allows multiple numeric types to be accepted during construction, while the stored type is generalized as `Number`.
- `T extends Number` ensures only numeric types (Integer, Double, Float, Long, etc.) can be passed.

BENEFITS:
- Enforces type safety → prevents invalid types like `String`.
- Provides flexibility for initializing with various numeric subclasses.
- Avoids making the whole class generic when only the constructor requires generic behavior.

REAL-WORLD USE CASES:
- Utility classes that process numbers but don’t need to expose generics at the class level.
- Frameworks where flexibility at object creation is required (e.g., mathematical constants, measurement wrappers).
- Logging or serialization helpers where values may be different numeric types.

EXAMPLE USAGE:
```java
Box2 boxInt = new Box2(2);        // Integer
Box2 boxDouble = new Box2(3.14);  // Double

System.out.println("Box2 int: " + boxInt.getValue());     // 2
System.out.println("Box2 double: " + boxDouble.getValue()); // 3.14

// Box2 boxStr = new Box2("Hello");  //  Compile-time error

NOTES:
•	Difference vs Generic Class:
•	Generic Class: Type parameter applies to the whole class (e.g., Box<T>).
•	Generic Constructor: Type parameter applies only to the constructor (class stays non-generic).

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

Author: Someshdiwan

Section24JavaGenerics/src/GenericConstructors/Box2.java

@@ -0,0 +1,51 @@
+package GenericConstructors;
+
+public class Box2 {
+    private Number value;
+
+    // Generic constructor
+    public <T extends Number> Box2(T value) {
+        this.value = value;
+    }
+
+    public Number getValue() {
+        return value;
+    }
+
+    public static void main(String[] args) {
+        Box2 boxInt = new Box2(2);        //Integer
+        Box2 boxDouble = new Box2(3.14);  //Double
+
+        System.out.println("Box2 int: " + boxInt.getValue());
+        System.out.println("Box2 double: " + boxDouble.getValue());
+    }
+}
+
+/*
+1. Non-Generic Class + Generic Constructor:
+   - Class `Box2` khud generic nahi hai (iska type parameter <T> nahi hai).
+   - Lekin isme ek **generic constructor** banaya gaya hai:
+        public <T extends Number> Box2(T value)
+   - Matlab: constructor ko call karte waqt tum koi bhi `Number` subclass (Integer, Double, Float, Long, etc.)
+     pass kar sakte ho.
+
+2. Working:
+   - new Box2(2);       // Integer (autoboxed to Number)
+   - new Box2(3.14);    // Double
+   - Constructor accept karta hai dono, kyunki dono `Number` ke subclasses hain.
+   - Internally `this.value` me as a `Number` store hota hai.
+
+3. Difference from Generic Class:
+   - Agar class generic hoti (`class Box<T extends Number>`), toh value specific type me store hoti.
+   - Yaha class non-generic hai, isliye har value ko `Number` type me store kiya jaata hai.
+
+4. Advantage:
+   - Reusability → ek hi class ka constructor alag-alag numeric types accept kar leta hai.
+   - Compile-time safety → sirf `Number` subclasses hi pass kar sakte ho.
+   - Flexibility → bina class ko generic banaye, tum generic behavior pa lete ho.
+
+✔ Class non-generic hai, lekin constructor generic hai.
+✔ `<T extends Number>` ensure karta hai ki sirf numeric types pass ho.
+✔ Internally `Number` type ke variable me store hota hai.
+✔ Useful jab tumhe sirf `Number` values store karni ho, lekin flexibility maintains karni ho.
+*/