feat: implement Comparable<Employee1> for natural ordering by age

WHAT:
- Created `Employee1` class with fields `name` and `age`.
- Implemented `Comparable<Employee1>` to define natural ordering logic.
- Overrode `compareTo(Employee1 other)` using `Integer.compare()` to compare ages.
- Implemented `toString()` for clear object representation.
- Added `TestEmployee` class to demonstrate comparison between employees.

WHY:
- Shows how to use Java’s generic interface `Comparable<T>` to enforce type-safe comparison rules.
- Provides a clean, reusable way to sort or prioritize custom objects without external comparator logic.
- Demonstrates polymorphism: comparison logic is embedded in the object itself, making sorting collections intuitive.

HOW (Logic Flow):
1. `Employee1` objects are created with names and ages.
2. When `compareTo()` is called:
   - If this.age > other.age → returns positive.
   - If this.age < other.age → returns negative.
   - If equal → returns zero.
3. This comparison behavior integrates seamlessly with:
   - `Collections.sort(List<Employee1>)`
   - Priority-based data structures like `TreeSet`, `PriorityQueue`
   - Java Streams `.sorted()`

BENEFITS:
- Strong compile-time type safety (`Comparable<Employee1>` ensures only Employee1 objects compared).
- Simplifies sorting logic in larger applications — no extra comparator needed for default behavior.
- Clean and maintainable — toString() makes debugging and logging easier.

REAL-WORLD APPLICATIONS:
- Sorting employees by age in HR or payroll systems.
- Prioritizing users in queue management systems (e.g., oldest first).
- Any business domain where objects require a natural ordering rule.

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

Author: Someshdiwan

Section24JavaGenerics/src/GenericInterface/Employee1.java

@@ -1,36 +1,40 @@
 package GenericInterface;
 
-/*
-Real-World Example of Generic Interfaces
-
-A common example of a generic interface in Java is the Comparable<T> interface, which is used to impose a natural ordering on objects.
-*/
-
-/*public class Employee1 implements Comparable<Employee> {
+public class Employee1 implements Comparable<Employee1> {
     private String name;
     private int age;
 
-    public Employee(String name, int age) {
+    public Employee1(String name, int age) {
         this.name = name;
         this.age = age;
     }
 
     @Override
-    public int compareTo(Employee other) {
+    public int compareTo(Employee1 other) {
         return Integer.compare(this.age, other.age);
     }
-}*/
 
+    @Override
+    public String toString() {
+        return name + " (" + age + ")";
+    }
+}
 
 /*
-In this example, the Comparable<Employee> interface ensures that the Employee objects can be compared based on their age.
-Summary
+Real-World Example of Generic Interfaces:
+A common example of a generic interface in Java is the Comparable<T> interface, which is used to impose a
+natural ordering on objects.
+
+In this example, the Comparable<Employee> interface ensures that the Employee objects can be compared based on
+their age.
+
+Summary:
 A generic interface allows you to write interfaces that can handle various types specified at the time of implementation.
 Type parameters are used to define the type of objects that the interface will work with.
 You can implement a generic interface by specifying the type or by keeping the implementation generic.
 Multiple type parameters can be used to work with more than one type at a time.
 Bounded type parameters restrict the types that can be passed to the generic interface.
 Wildcards can be used in generic interfaces for flexibility in accepting various types.
 Generic interfaces in Java are powerful tools that increase the reusability and flexibility of your code by
-allowing you to abstract behaviour across multiple types, while maintaining type safety at compile time.
-*/
+allowing you to abstract behavior across multiple types, while maintaining type safety at compile time.
+*/

Section24JavaGenerics/src/GenericInterface/TestEmployee.java

@@ -0,0 +1,11 @@
+package GenericInterface;
+
+public class TestEmployee {
+    public static void main(String[] args) {
+        Employee1 e1 = new Employee1("Alice", 30);
+        Employee1 e2 = new Employee1("Bob", 25);
+
+        int result = e1.compareTo(e2);
+        System.out.println(result);  // >0 means e1 is older, <0 means e2 is older
+    }
+}