15.10.2. Upper Bounded Wildcards

Upper Bounded Wildcards: <? extends T> allows reading items of type T or its subtypes.

Upper Bounded Wildcards are a feature in Java Generics that allow us to specify a range of acceptable types. When we use the notation <? extends T>, we are informing the compiler that we want to work with a type that is T or a subtype of T. This capability is particularly useful for methods that read data. For example, if we have a method that processes numbers, we can declare it to accept not just Number, but also any subtype of Number – like Integer or Double. Thus, we can work with a broader range of types while ensuring type safety.

Think of Upper Bounded Wildcards like a filter at a library that allows people to borrow books, not just from the entire library, but specifically from the 'Science Fiction' genre and its subgenres, like 'Dystopian' or 'Space Opera'. Just as the library filter permits only certain types of books, Upper Bounded Wildcards allow a method to process only certain types of data, making it easier to manage related items.

They are used when a method needs to read from a collection of elements that share a common superclass.

Upper Bounded Wildcards are useful in scenarios where you want to create a method that can operate on a class and its subclasses. For instance, if you have a method that deals with a list of numbers, using a wildcard allows that method to take not just a list of Numbers, but also a list of subclasses, like ArrayList or ArrayList. This provides flexibility and reusability in your code, allowing your method to handle a variety of input types without losing type safety.

Imagine a kitchen appliance that can only work with certain ingredients - like a blender for liquids. If you have a recipe that accepts any liquid (juice, water, milk), you wouldn't want to use solid ingredients like fruits whole—your blender wouldn't work properly with that. Similarly, Upper Bounded Wildcards allow functions to work with a range of acceptable types, ensuring that the input is appropriate for the operations that will be performed.

Consider a method that processes a list of numbers:

public void processNumbers(List<? extends Number> numbers) {
    for (Number num : numbers) {
        System.out.println(num);
    }
}

This example demonstrates a method named 'processNumbers' that accepts a list of numbers of any subtype of the Number class, such as Integer or Double. The method iterates over the elements in the provided list and prints each number. This highlights the ability of upper bounded wildcards to simplify method design while maintaining type safety. By using List<? extends Number>, the method now supports various numeric types without needing to create multiple overloaded methods.

Suppose you're volunteering at an art exhibition and you are tasked with describing various art pieces. By saying you will only describe paintings, you're using a form of filtering—only letting specific items come through (like Upper Bounded Wildcards). If anyone brings any type of painting (oil, watercolor, acrylic), you're prepared to discuss it. Similarly, the 'processNumbers' method is ready to handle any numerical input that fits the description, facilitating smoother interaction while avoiding mismatches.

--