refactor(generic-types): replace Object-based Box with type-safe generic BoxIMP<T>

WHAT:
- Introduced `BoxIMP<T>` class using generics instead of raw `Object`.
- Getter and setter methods now operate directly on the type parameter `T`.
- Updated `Main` to demonstrate safe usage with `BoxIMP<Integer>`.

WHY:
- The earlier `Box` implementation required casting (`(String) box.getValue()`)
  which caused runtime `ClassCastException`.
- Generics enforce compile-time type safety, eliminating the need for unsafe casts.
- Improves readability, maintainability, and robustness of the code.

HOW:
- Defined class as `public class BoxIMP<T>`.
- `setValue(T value)` ensures only correct type can be stored.
- `getValue()` returns `T` directly, avoiding explicit casting.
- Example: `BoxIMP<Integer>` ensures only integers can be set and retrieved safely.

BENEFITS:
- Prevents runtime casting errors by shifting checks to compile time.
- Cleaner, more expressive code (`BoxIMP<Integer>` vs `Box` with Object).
- Reusable for multiple types (e.g., `BoxIMP<String>`, `BoxIMP<Double>`).

REAL-WORLD APPLICATION:
- Similar to how Java Collections Framework uses generics (e.g., `List<String>`).
- Useful in designing APIs or libraries where container classes must be flexible but type-safe.

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

Author: Someshdiwan

Section24JavaGenerics/src/GenericTypes/BoxIMP.java

@@ -1,9 +1,6 @@
 package GenericTypes;
 
 public class BoxIMP<T> {
-   /* one or more type parameters
-      These type parameters are placeholders that are replaced with specific types when the class is instantiated.
-   */
     private T value;
 
     public T getValue() {
@@ -18,18 +15,27 @@ public void setValue(T value) {
 class Main {
     public static void main(String[] args) {
         BoxIMP<Integer> box = new BoxIMP<>();  // Box is now type-safe
+
         box.setValue(1);  // No issue, it's an Integer
+
         Integer i = box.getValue();  // No casting needed
         System.out.println(i);
     }
 }
 
 /*
-Here, Box<T> is a generic class. The type parameter T will be replaced with a specific type when an object of Box is created.
-Now, the Box class is type-safe, and we will not encounter the ClassCastException because the types are enforced at compile time.
+one or more type parameters, These type parameters are placeholders that are replaced with specific types when the
+class is instantiated.
+
+Here, Box<T> is a generic class. The type parameter T will be replaced with a specific type when an object of Box is
+created.
+
+Now, the Box class is type-safe, and we will not encounter the ClassCastException because the types are enforced at
+compile time.
 
-So, In simpler terms, generics allow you to write code that can work with any object type while ensuring type safety at compile time.
+So, In simpler terms, generics allow you to write code that can work with any object type while ensuring type safety at
+compile time.
 
 Generics help us write more flexible and reusable code. For example, without generics,
 we would have to write multiple versions of the same class to handle different data types, leading to code duplication.
-*/
+*/