feat(generic-interface): add generic Container interface with concrete and generic implementations

WHAT:
- Introduced a generic interface `Container<T>` with two core operations:
  - `add(T item)` → store an item.
  - `T get()` → retrieve the stored item.
- Added two implementations:
  1. `StringContainer` → fixed to work only with `String` type.
  2. `GenericContainer<T>` → fully generic, supports any type at instantiation.
- Added `Main` class to demonstrate usage with `String` and `Integer`.

WHY:
- To illustrate how generic interfaces enable type-safe contracts that can be implemented differently:
  - Specialized implementation (e.g., `StringContainer`).
  - Reusable generic implementation (e.g., `GenericContainer<T>`).
- Avoids boilerplate and unsafe casting while maintaining flexibility.

HOW (Logic Flow):
1. Define `Container<T>` interface → abstraction with generic type parameter `T`.
2. Implement with `StringContainer` (type fixed) and `GenericContainer<T>` (fully reusable).
3. Demonstrate instantiation:
   - `StringContainer` stores and retrieves `String`.
   - `GenericContainer<Integer>` stores and retrieves an `Integer`.

BENEFITS:
- Provides compile-time type safety.
- Eliminates the need for explicit casting when retrieving values.
- Increases reusability by supporting both specific and generic use cases.

REAL-WORLD APPLICATIONS:
- Mirrors patterns in Java Collections API (`List<T>`, `Set<T>`, `Map<K,V>`).
- Useful in dependency injection, caching, and data processing frameworks.
- Can serve as the foundation for building strongly typed containers for domain-specific logic.

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

Author: Someshdiwan

Section24JavaGenerics/src/GenericInterface/Main.java

@@ -1,12 +1,12 @@
 package GenericInterface;
 
-// Define a generic interface
+// Define a generic interface.
 interface Container<T> {
     void add(T item);
     T get();
 }
 
-// Specific implementation for String
+// Specific implementation for String.
 class StringContainer implements Container<String> {
     private String item;
 
@@ -19,7 +19,7 @@ public String get() {
     }
 }
 
-// Generic implementation for any type
+// Generic implementation for any type.
 class GenericContainer<T> implements Container<T> {
     private T item;
 
@@ -36,20 +36,19 @@ public T get() {
 
 public class Main {
     public static void main(String[] args) {
-        // Using StringContainer
+        // Using StringContainer.
         StringContainer strContainer = new StringContainer();
         strContainer.add("Hello, Generics!");
         System.out.println(strContainer.get());
 
-        // Using GenericContainer
+        // Using GenericContainer.
         GenericContainer<Integer> intContainer = new GenericContainer<>();
         intContainer.add(42);
         System.out.println(intContainer.get());
     }
 }
-//In this example, StringContainer implements the Container interface with String as the specified type parameter.
-
 
+//In this example, StringContainer implements the Container interface with String as the specified type parameter.
 
 /*
 class GenericContainer<T> implements Container<T> {