docs(generics): explain and demonstrate generic interfaces in Java

WHAT:
- Added documentation and example code for a generic interface `Container<T>`.
- Defined two methods:
  - `add(T item)` → accepts items of generic type `T`.
  - `T get()` → retrieves items of type `T`.
- Highlighted how type parameters make the interface reusable for any data type.

WHY:
- Generic interfaces abstract behavior without tying code to specific data types.
- Provides compile-time type safety and reduces casting errors.
- Promotes reusability and flexibility in API design.

HOW (Logic Flow):
1. Declare `Container<T>` with type parameter `T`.
2. Expose operations `add()` and `get()` that use the type parameter.
3. At implementation or instantiation, specify the concrete type (e.g., `Container<String>`).
4. The compiler enforces type correctness without explicit casts.

BENEFITS:
- One interface works for multiple data types (String, Integer, custom objects).
- Strong compile-time checks reduce runtime errors.
- Clean, readable code with less duplication.

REAL-WORLD APPLICATIONS:
- Core part of Java Collections API (e.g., `List<T>`, `Set<T>`).
- Used in dependency injection frameworks to abstract type-safe object containers.
- Useful in designing APIs where the data type is not known upfront but defined later.
- Enables flexibility in libraries and frameworks that handle heterogeneous data.

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

Author: Someshdiwan

Section24JavaGenerics/src/GenericInterface/Interface

@@ -1,4 +1,5 @@
 A generic interface in Java allows you to define an interface with type parameters.
+
 This means that the interface can work with any type specified at the time of implementation.
 Generic interfaces are commonly used when the type of the objects that the interface deals with is not known until runtime.
 
@@ -11,8 +12,8 @@ interface Container<T> {
 }
 
 In this example, T is the generic type parameter for the Container interface.
-The add method accepts an argument of type T, and the get method returns a value of type T.
 
+The add method accepts an argument of type T, and the get method returns a value of type T.
 
-When you implement a generic interface, you need to specify the type for the generic parameter, or
-you can continue to make the implementation generic by using type parameters.
+When you implement a generic interface, you need to specify the type for the generic parameter,
+or you can continue to make the implementation generic by using type parameters.