feat(generics): add example of upper-bounded wildcards with Number

WHAT:
- Implemented a `sum(List<? extends Number> numbers)` method that demonstrates
  the use of **upper-bounded wildcards** in generics.
- Showed how a single method can handle lists of different numeric types
  (`Integer`, `Double`, etc.) by leveraging `? extends Number`.

WHY:
- Upper-bounded wildcards (`? extends T`) allow flexibility in reading values from
  collections while maintaining type safety.
- Ensures the method can work with any subtype of `Number` without overloading.

DETAILS:
- Iterates through a generic list of numbers and calculates the total sum by
  converting each element to `doubleValue()`.
- Demonstrated usage with:
  - `List<Integer>` → produces `6.0`
  - `List<Double>` → produces `6.6`

BENEFITS:
- Promotes code reuse by writing one method that works for multiple numeric types.
- Avoids duplication and unnecessary overloads.
- Ensures compile-time type safety (prevents adding non-numeric types).

REAL-WORLD CONTEXT:
- Useful in math utilities, statistics calculators, or APIs dealing with mixed
  numeric types.
- Builds foundation for understanding the difference between `? extends T`
  (safe for reading) and `? super T` (safe for writing).

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

Author: Someshdiwan

Section24JavaGenerics/src/UpperBoundedWildcards/Main.java

@@ -0,0 +1,31 @@
+package UpperBoundedWildcards;
+
+import java.util.List;
+
+public class Main {
+    public static double sum(List<? extends Number> numbers) {
+        double total = 0.0;
+
+        for (Number number : numbers) {
+            total += number.doubleValue();
+        }
+        return total;
+    }
+
+    public static void main(String[] args) {
+        List<Integer> intList = List.of(1, 2, 3);
+        List<Double> doubleList = List.of(1.1, 2.2, 3.3);
+
+        System.out.println("Sum of integers: " + sum(intList));
+        System.out.println("Sum of doubles: " + sum(doubleList));
+    }
+}
+
+/*
+Explanation:
+List<? extends Number> allows the sum method to accept a List of any type that extends Number, such as Integer, Double,
+Float, etc.
+The method can read elements from the list, but it cannot add elements to it
+(because it only knows that the elements are some subtype of Number, but it doesn't know the exact type).
+This flexibility is achieved using the upper-bounded wildcard ? extends Number.
+*/