What Are Bounded Type Parameters?

A bounded type parameter restricts what a type argument may be. You write <T extends SomeType>, and the compiler then guarantees that every T is a SomeType — which means you can call SomeType's methods on a value of type T inside the method body.

That guarantee is the entire point. Without a bound, a generic method can only do things that work for any object, which usually means storing and retrieving it. With a bound, you can operate on it.

import java.util.List;

public class Main {
    public static void main(String[] args) {
        System.out.println("max of ints   : " + max(3, 9, 4));
        System.out.println("max of doubles: " + max(1.5, 0.5, 2.25));
        System.out.println("sum of ints   : " + sum(List.of(1, 2, 3)));
    }

    // T is known to be Comparable, so compareTo is available.
    static <T extends Comparable<T>> T max(T first, T second, T third) {
        T best = first;
        if (second.compareTo(best) > 0) {
            best = second;
        }
        if (third.compareTo(best) > 0) {
            best = third;
        }
        return best;
    }

    // T is known to be a Number, so doubleValue is available.
    static <T extends Number> double sum(List<? extends T> values) {
        double total = 0;
        for (T value : values) {
            total += value.doubleValue();
        }
        return total;
    }
}

The output shows the bounds doing their job. The max method works for Integers and for Doubles because the bound says T is Comparable, and the compiler checks that every argument satisfies it. The sum method works with a List of Integers because the bound says the elements are Numbers.

Note the shape of the bound on max: extends Comparable<T> rather than extends Comparable. The self-referential form is the correct one, and it is what lets the compiler compare two values of type T with each other. Writing the raw Comparable would give you a compile error when you tried to call compareTo with a T argument, because the compiler could not prove the types line up.

Java supports only one bound per type parameter, and it must come first. If you need more than one constraint, the usual trick is to introduce an interface that extends the others and bound by that.

The restriction is that a type parameter is a type variable, not a class. So you cannot write new T(), you cannot cast to T without an unchecked warning, and you cannot use instanceof T — the check is illegal because the type is erased at run time and the information does not exist.

You also cannot reference a type parameter in a static context. A static field, a static method or the type arguments of a static nested class cannot mention T, because there is no instance for T to belong to.

The workarounds map cleanly onto the restriction. To produce a T when you cannot call the constructor, use a supplier — pass a Supplier<T> or a factory method in, and the caller decides how the object is made. To test the runtime type of a T, accept an Object instead and narrow it with instanceof. And to build a generic pair or container, use a static factory method on the generic class, which lets the compiler infer the type arguments at the call site.

public class Main {
    public static void main(String[] args) {
        // You cannot write new T() - a type parameter is not a class.
        Pair<String, Integer> pair = Pair.of("answer", 42);
        System.out.println("pair     : " + pair);

        // The standard workarounds.
        Factory<String> factory = () -> "made by the factory";
        System.out.println("factory  : " + factory.create());

        Mapper<String, Integer> length = String::length;
        System.out.println("length   : " + length.map("tutorsbot"));
    }
}

class Pair<A, B> {
    private final A first;
    private final B second;

    private Pair(A first, B second) {
        this.first = first;
        this.second = second;
    }

    static <A, B> Pair<A, B> of(A first, B second) {
        return new Pair<>(first, second);
    }

    @Override
    public String toString() {
        return "(" + first + ", " + second + ")";
    }
}

@FunctionalInterface
interface Factory<T> {
    T create();
}

@FunctionalInterface
interface Mapper<A, B> {
    B map(A input);
}

The output shows the three patterns in use. The static factory method of the generic Pair infers both type arguments from the arguments, so the caller gets a properly typed pair without writing the type arguments out. The supplier creates a String without the generic class ever needing a constructor. And the mapper works on a String without any casting.

The design lesson is worth stating: when the type parameter represents a value rather than a type, model the creation of that value as an abstraction too. A generic method that accepts a Supplier is far more flexible than one that tries to instantiate T itself, and it is the pattern the modern standard library uses throughout.