feat(generics-upper-bounds): add example of upper-bounded wildcards with Animal hierarchy

WHAT:
- Introduced `Animal` base class with subclasses `Dog` and `Cat`, each overriding `sound()`.
- Implemented method `makeSound(List<? extends Animal>)` that accepts a list of any subclass of `Animal`.
- Demonstrated runtime polymorphism by passing `List<Dog>` and `List<Cat>` to the method.

WHY:
- Showcases how upper-bounded wildcards (`? extends Animal`) allow methods to operate on collections of a type and its subtypes.
- Useful for read-only scenarios where elements are consumed but not safely added (PECS principle: Producer Extends).
- Demonstrates real-world applicability: handling heterogeneous animal types with one generic method.

DETAILS:
- `List<? extends Animal>` ensures flexibility to accept both `List<Dog>` and `List<Cat>`.
- Iteration treats elements as `Animal` → enabling polymorphic method calls like `animal.sound()`.
- Prevents unsafe additions (cannot add a `Dog` to `List<? extends Animal>` safely, except `null`).

BENEFITS:
- Promotes reusable and type-safe code when processing different subclasses in collections.
- Demonstrates dynamic method dispatch via generics and wildcards.
- Reinforces understanding of covariance in generics (`? extends T`).

REFERENCE:
- PECS Principle:
  - Producer → `? extends T` (safe for reading).
  - Consumer → `? super T` (safe for writing).

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

Author: Someshdiwan

Section24JavaGenerics/src/UpperBoundedWildcards/AnimalDemo.java

@@ -0,0 +1,66 @@
+package UpperBoundedWildcards;
+
+import java.util.List;
+
+class Animal {
+    public void sound() {
+        System.out.println("Some sound");
+    }
+}
+
+class Dog extends Animal {
+    @Override
+    public void sound() {
+        System.out.println("Bark");
+    }
+}
+
+class Cat extends Animal {
+    @Override
+    public void sound() {
+        System.out.println("Meow");
+    }
+}
+
+public class AnimalDemo {
+    public static void makeSound(List<? extends Animal> animals) {
+        for (Animal animal : animals) {
+            animal.sound();
+        }
+    }
+
+    public static void main(String[] args) {
+        List<Dog> dogs = List.of(new Dog(), new Dog());
+        List<Cat> cats = List.of(new Cat(), new Cat());
+
+        makeSound(dogs);
+        makeSound(cats);
+    }
+}
+
+/*
+1. Classes:
+   - `Animal` base class with method `sound()`.
+   - `Dog` and `Cat` extend `Animal` and override `sound()` with specific behavior.
+
+2. Upper-Bounded Wildcard:
+   - Method signature: `makeSound(List<? extends Animal> animals)`
+   - `? extends Animal` means:
+     ✔ You can pass a `List<Dog>` or `List<Cat>` or any subclass of `Animal`.
+     ✔ Read-only (safe to read as `Animal`), but you cannot safely add new elements to `animals`
+       because compiler doesn’t know the exact subtype.
+
+3. Logic:
+   - For-each loop: `for (Animal animal : animals)` → safe because every element is guaranteed to be an `Animal`.
+   - Calls `animal.sound()` which resolves to the overridden version (`Bark` for Dog, `Meow` for Cat).
+
+4. Main Method:
+   - `List.of(new Dog(), new Dog())` → immutable list of Dogs.
+   - `List.of(new Cat(), new Cat())` → immutable list of Cats.
+   - Both are passed to `makeSound()`, demonstrating polymorphism + upper-bounded wildcard flexibility.
+
+✔ `? extends Animal` = accept a list of any subclass of Animal.
+✔ Safe to read elements as `Animal`, but you cannot add new elements.
+✔ Useful for covariant read-only operations.
+✔ Demonstrates polymorphism: Dogs bark, Cats meow, all via one generic method.
+*/