feat(generics): add GenericClass2 with multiple type parameters <T,U>

WHAT:
- Implemented a generic class `Test2<T,U>` that supports two independent type parameters.
- Added fields `obj1` and `obj2` of types `T` and `U` respectively.
- Provided constructor for initialization and a `print()` method to display values.
- Created `GenericClassDemo2` with a demo instantiation: `Test2<String,Integer>`.

WHY:
- Demonstrates how Java Generics can handle multiple type parameters.
- Shows how to design reusable classes that store heterogeneous data while maintaining type safety.
- Example builds on the idea of single type parameter classes like `Box<T>`.

HOW:
- Declared `class Test2<T,U>` with two type parameters.
- `obj1` stores a value of type `T`, `obj2` stores a value of type `U`.
- Constructor initializes both values.
- `print()` outputs both stored objects.
- In `main()`, instantiated `Test2<String,Integer>` with `"Multiple parameter"` and `15`.

TYPE PARAMETER CONVENTIONS:
- `<T, U>` are placeholder names:
  - `T` → Type (general placeholder)
  - `U` → Second independent type
- Other common conventions:
  - `E` → Element (used in collections like `List<E>`)
  - `K` → Key
  - `V` → Value
  - `N` → Number

REAL-WORLD USE CASES:
- **Pairs/Tuples**: Represent related but different data types (e.g., name and ID).
- **Database records**: Store column name (`String`) with its value (`Object` or typed).
- **Key-value relationships**: Similar to `Map.Entry<K,V>` in Java Collections Framework.
- **Generic utility classes**: For passing/returning heterogeneous values safely.

NOTES:
- Unlike raw `Object`-based storage, generics eliminate the need for casting.
- Java’s `Map.Entry<K,V>` is a direct application of this pattern.
- Further enhancements could include methods like `getFirst()` and `getSecond()` for readability.

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

Author: Someshdiwan

Section24JavaGenerics/src/GenericClassDemo2.java renamed to Section24JavaGenerics/src/GenericClass2/GenericClassDemo2.java

@@ -1,36 +1,29 @@
+package GenericClass2;
 /*
 We can also pass multiple Type parameters in Generic classes.
-
-Java program to show multiple type parameters in Java Generics
-
-We use < > to specify Parameter-type.
+Java program to show multiple type parameters in Java Generics, We use < > to specify Parameter-type.
 */
 
-class Test2<T, U>
-{
+class Test2<T, U> {
     T obj1;  // An object of type T
     U obj2;  // An object of type U
 
     // constructor
-    Test2(T obj1, U obj2)
-    {
+    Test2(T obj1, U obj2) {
         this.obj1 = obj1;
         this.obj2 = obj2;
     }
 
     // To print objects of T and U
-    public void print()
-    {
+    public void print() {
         System.out.println(obj1);
         System.out.println(obj2);
     }
 }
 
-class GenericClassDemo2
-{
-    public static void main (String[] args)
-    {
+class GenericClassDemo2 {
+    public static void main (String[] args) {
         Test2<String, Integer> obj = new Test2<>("Multiple parameter", 15);
         obj.print();
     }
-}
+}