docs(generics): add comprehensive guide to Java Generics

- Introduced parameterized types (classes, interfaces, and methods) with clear explanation of benefits:
  ✔ Code reusability across multiple data types
  ✔ Compile-time type safety
  ✔ Removal of explicit type casting
  ✔ Improved readability and maintainability

- Added table of common type parameter conventions (T, E, K, V, N).
- Covered major types of generics with examples:
  • Generic Classes (MyGenericClass<T>)
  • Generic Methods (<T> methodName)
  • Generic Interfaces (GenericInterface<T>)

- Highlighted practical usage in Collections with comparison of pre-generics vs generics.
- Documented advantages (flexibility, type safety, generic algorithms) and disadvantages
  (complex wildcards, type erasure limitations, lack of primitive support).
- Provided detailed examples for readability, including Box, printArray, and interface implementations.

This commit adds a full reference for learning and applying generics effectively in modern Java projects.

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

Author: Someshdiwan

Section24JavaGenerics/src/Generics in Java.txt

@@ -1,12 +1,10 @@
-Generics in Java
-
----
+Generics in Java:
 
 Java Generics – A Comprehensive Guide
 
-Introduction to Generics
-
-Generics in Java introduce parameterized types, allowing classes, interfaces, and methods to operate on different data types while ensuring type safety at compile time.
+Introduction to Generics:
+Generics in Java introduce parameterized types, allowing classes, interfaces, and methods to operate on different data
+types while ensuring type safety at compile time.
 
 For example, Java Collections like ArrayList, HashSet, and HashMap use generics to allow flexible and safe data storage.
 
@@ -17,7 +15,7 @@ Key Benefits:
 ✔ Improved Code Readability & Maintainability – Clearer intent and structure.  
 
 
-Common Type Parameters in Generics
+Common Type Parameters in Generics:
 
 Java uses naming conventions for generic type parameters:
 
@@ -29,59 +27,47 @@ Java uses naming conventions for generic type parameters:
 |     V     | Value (used in maps)          |
 |     N     | Number                        |
 
-
-
 class GenericClass<T> {
     T obj;  
     GenericClass(T obj) { this.obj = obj; }
     void showType() { System.out.println("Type: " + obj.getClass().getName()); }
 }
 
-Types of Java Generics
-
-1. Generic Classes
+Types of Java Generics:
 
-A generic class allows defining a class that can operate on any data type.  
+1. Generic Classes:
+A generic class allows defining a class that can operate on any data type.
 
 Syntax:
-
 class MyGenericClass<T> {
     T data;
     MyGenericClass(T data) { this.data = data; }
 }
 
 Example Usage:
-
 MyGenericClass<String> obj1 = new MyGenericClass<>("Hello");
 MyGenericClass<Integer> obj2 = new MyGenericClass<>(100);
 
-2. Generic Methods
-
+2. Generic Methods:
 A generic method allows a method to work with different data types.  
 
 Syntax:
-
 class GenericMethodExample {
     static <T> void printArray(T[] arr) {
         for (T item : arr) System.out.println(item);
     }
 }
 
-
 Usage:
-
 String[] words = {"Apple", "Banana", "Cherry"};
 Integer[] numbers = {1, 2, 3};
 
 GenericMethodExample.printArray(words);
 GenericMethodExample.printArray(numbers);
 
-
-3. Generic Interfaces:
-
+3. Generic Interfaces::
 An interface can also be generic.
 
-
 interface GenericInterface<T> {
     void display(T value);
 }
@@ -96,24 +82,21 @@ GenericImpl<Integer> obj = new GenericImpl<>();
 
 obj.display(50);
 
-Advantages of Generics
+Advantages of Generics:
+Code Reusability – Works with multiple types without rewriting code.
+Type Safety – Compile-time checks prevent errors.
+No Need for Type Casting – Reduces redundant casting operations.
+Readability & Maintainability – Code becomes more structured.
+Generic Algorithms – Algorithms can be implemented flexibly.
 
-✅ Code Reusability – Works with multiple types without rewriting code.  
-✅ Type Safety – Compile-time checks prevent errors.  
-✅ No Need for Type Casting – Reduces redundant casting operations.  
-✅ Readability & Maintainability – Code becomes more structured.  
-✅ Generic Algorithms – Algorithms can be implemented flexibly.
 
+Disadvantages of Generics:
+Complexity – Wildcards (`? extends`, `? super`) can be tricky.
+Performance Overhead – Type erasure at runtime can cause inefficiency.
+No Primitive Types – Generics work only with objects (e.g., `Integer`, not `int`).
+Limited Reflection – Type information is lost due to type erasure.
 
-Disadvantages of Generics
-
-❌ Complexity – Wildcards (`? extends`, `? super`) can be tricky.  
-❌ Performance Overhead – Type erasure at runtime can cause inefficiency.  
-❌ No Primitive Types – Generics work only with objects (e.g., `Integer`, not `int`).  
-❌ Limited Reflection – Type information is lost due to type erasure.  
-
-
-Example: Generics in Collections
+Example: Generics in Collections:
 
 Without Generics (older Java versions):  
 
@@ -131,5 +114,5 @@ String name = list.get(0); // No need for casting
 
 
 Conclusion:
-
-Generics in Java provide flexibility, type safety, and reusability, making them a crucial part of modern Java programming. While they introduce some complexity, mastering generics significantly improves code quality.
+Generics in Java provide flexibility, type safety, and reusability, making them a crucial part of modern Java programming.
+While they introduce some complexity, mastering generics significantly improves code quality.