feat: implement bounded type parameters in a generic Box class

WHAT:
- Added `Box<T extends Number>` class in `BoundedTypesinInterfaces` package.
- Created `Main.java` to demonstrate usage of bounded generics.
- Restricted type parameter `T` to subclasses of `Number` (e.g., Integer, Float, Double).
- Showed compile-time error when attempting to use a non-Number type (e.g., String).

HOW:
1. `Box<T extends Number>`:
   - Declares a generic class where `T` must be a subclass of `java.lang.Number`.
   - Ensures only numeric types can be stored in the `Box`.
   - Provides `getValue()` and `setValue()` methods to access and modify the value.

2. `Main.java`:
   - Demonstrates a valid instantiation with `Box<Integer>`.
   - Commented example `Box<String>` shows compile-time restriction (invalid type).

WHY:
- Enforcing bounds (`T extends Number`) ensures that only valid numeric types are allowed.
- Prevents misuse of the class with incompatible data types.
- Improves type safety and readability by making constraints explicit.

REAL-WORLD APPLICATIONS:
- Bounded generics are useful in mathematical utility classes, statistical libraries,
  or any domain where only numeric data makes sense.
- For example, implementing a generic `Calculator<T extends Number>` or `Statistics<T extends Number>`.

NOTES:
- `Box<Integer>`, `Box<Double>`, and `Box<Float>` work correctly.
- `Box<String>` fails at compile-time, avoiding runtime errors.

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

Author: Someshdiwan

Section24JavaGenerics/src/BoundedTypesinInterfaces/Box.java

@@ -0,0 +1,13 @@
+package BoundedTypesinInterfaces;
+
+public class Box<T extends Number> {
+    private T value;
+
+    public T getValue() {
+        return value;
+    }
+
+    public void setValue(T value) {
+        this.value = value;
+    }
+}

Section24JavaGenerics/src/BoundedTypesinInterfaces/Main.java

@@ -0,0 +1,37 @@
+package BoundedTypesinInterfaces;
+
+public class Main {
+    public static void main(String[] args) {
+        Box<Integer> box = new Box<>();
+        //Bounded type parameter laga deya hai.
+
+        //Box<String> box = new Box<String>();
+        //remove comment and check error.
+    }
+}
+
+/*
+1. Generic Class `Box<T extends Number>`:
+   - Yaha `T` ek **bounded type parameter** hai.
+   - Matlab `T` sirf `Number` class ya uske subclasses (Integer, Double, Float, Long, etc.) hi ho sakte hain.
+   - Example: `Box<Integer>`, `Box<Double>` valid hai.
+   - Example: `Box<String>` error dega, kyunki String Number ka subclass nahi hai.
+
+2. Why Bound Generics?
+   - Jab tumhe generics ke andar sirf specific type hierarchy allow karni ho.
+   - Example: Agar tumhe mathematical calculations karni hain → toh sirf `Number` aur uske subclasses ka support chahiye.
+
+3. getValue() / setValue():
+   - `getValue()` → box ke andar ka value return karta hai.
+   - `setValue(T value)` → box ke andar ek naya value set karne deta hai.
+   - Type safety maintain hoti hai, kyunki `T` fixed hai (Integer, Double etc.).
+
+4. Main Class:
+   - `Box<Integer> box = new Box<>();` → sahi hai (Integer extends Number).
+   - Agar `Box<String>` try karoge toh compile-time error aayega.
+     - Error: "Type parameter String is not within its bound".
+
+✔ `T extends Number` → bounded generics, sirf Number aur uske subclasses allowed.
+✔ Compile-time safety: galat type (jaise String) detect ho jaati hai.
+✔ Useful jab tumhe generics me type restriction enforce karna ho.
+*/