6.5. Bounded Type Parameters

Used to restrict generic types to a specific class or interface.

Bounded type parameters allow developers to limit the types that can be used as arguments for a generic class. By doing so, we ensure that only certain types, usually those derived from a specific class or implementing a specific interface, can be used. This approach helps enforce stricter type safety, making our code more predictable and reducing errors related to incorrect type usage.

Think of bounded type parameters as a bouncer at a club who checks IDs at the entrance. Only certain types (IDs of specific age groups) are allowed in (as in, only certain types can be used in your code). This way, you maintain a certain standard (type safety) inside the club (your program).

Syntax:

class Stats<T extends Number> {
    T[] nums;
    Stats(T[] nums) {
        this.nums = nums;
    }
    double average() {
        double sum = 0.0;
        for (T num : nums)
            sum += num.doubleValue();
        return sum / nums.length;
    }
}

In this syntax, T is a type parameter that is restricted to types that extend the Number class. This means that T can be any real number type like Integer, Double, or Float. When creating an instance of the Stats class, you can only pass an array of types that are considered numbers. Inside the class, you can safely perform operations that are specific to Number, such as calling doubleValue() on T.

Imagine you own a gym that only accepts members who are either beginners or advanced athletes (representing Number and its subclasses). If a new member tries to join (like a new type being used in Stats), they must fit in one of these categories (extend Number), ensuring they can handle the gym's equipment (the operations that can be performed within the class).

double average() {
    double sum = 0.0;
    for (T num : nums)
        sum += num.doubleValue();
    return sum / nums.length;
}

The average method demonstrates a practical application of bounded type parameters. It calculates the average of the numbers stored in the nums array. By using T which is bound to Number, the method can call doubleValue(), which is a method defined in the Number class. This ensures that the code is type-safe and that the program doesn't crash due to incorrect type handling.

Let's relate this to calculating the average score of students. If you only allow grades (numbers) from certain types (like integers for exam scores), you can easily calculate the average without worrying about invalid data types (such as strings or characters). This is similar to how the average method restricts itself to only working with numbers.

--