Java Generics: extends, super and wildcards explained

Today we continue our mini-series on Java Generics. In previous posts we have investigated

Java type parameters are used as type placeholders.

public class List<X>  { }
A List<X> is a container for X objects, and X can be instantiated with any class: you can have List<Object>, List<String>, and List<Number>.

Introducing bounds: extends

You often want to restrict the set of types that can be used in instantiation. If you create a class Garage, you want it to hold only Vehicle objects.

The syntax you use in Java is like this:

public class Garage<X extends Vehicle> { }
Every time you instantiate the Garage, the type parameter has to be a subclass of Vehicle.

class Car extends Vehicle { }
class Motorcycle extends Vehicle { }
class Fruit extends Object { }
Thus Garage<Car> and Garage<Motorcycle> are OK but Garage<Fruit> is not OK.

You can specify more than one bound with extends:

class Vehicle { }
interface PassengerVehicle { }
interface MotorVehicle { }
class ParkingGarage<X extends Vehicle & MotorVehicle & PassengerVehicle>
You can specify at most one class in the bound (obviously, as you can only inherit from one class in Java) and as many interfaces as you want.

The bound can refer to the typing parameter:

class BST<X extends Comparable<X>> {}
BST class can only be instantiated with classes X which implement the Comparable<X> interface.

Bounds in method parameters

Java method can be parametrized, too. The syntax is as follows:

<T> T getRandomElement(List<T> list) {}
As with class definitions, you often want to restrict the type parameter in the method. A method which takes a list of Vehicles and returns the fastest vehicle in the list can have the following type.
<T extends Vehicle> T getFastest(List<T> list) { }
You can pass as argument a list of any vehicles. List<Car> is OK, List<Motorcycle> is OK, List<Vehicle> is OK, too. List<Number> is not OK.

Note that the following declaration wouldn't do the trick.

Vehicle getFastest2(List<Vehicle> list) { }
The argument to the method getFastest2 has to be exactly a List<Vehicle>, and not a List<Car>, because List<Car> is not a subtype of List<Vehicle>,


Take a look at the following declaration.

<T extends Vehicle> int totalFuel(List<T> list) { }
The parameter T occurs only once in the method signature, in an argument. You can imagine that the method body does not use the name T either. In this case you can use an alternative syntax, called wildcards, denoted with ?:
int totalFuel(List<? extends Vehicle> list) { }
The two signatures for totalFuel are equivalent. The meaning of <? extends Vehicle> is: I don't care what the type parameter is, as long as it is a subclass of Vehicle.

Introducing bounds: super

There is also dual bound, called super. As you guess it is used to denote that you can pass only superclasses of the bound. There are some differences between extends and super, though.

You can't use super in class declaration

The super bound is not allowed in class definition.

//this code does not compile !
class Forbidden<X super Vehicle> { }
Why? Because such construction doesn't make sense. For example, you can't erase the type parameter with Vehicle because the class Forbidden could be instantiated with Object. So you have to erase type parameters to Object anyway. If think about class Forbidden<Object>, it can take any value in place of X, not only superclasses of Vehicle. There's no point in using super bound, it wouldn't get us anything. Thus it is not allowed.


The syntax for wildcards is also similar to extends:

int totalValue(Valuer<? super Vehicle> valuer)
The method has to take a comparator which is able to compare Vehicles. If it compares Objects as well, that's fine too.

When to use extends and super

Wildcards are most useful in method parameters. They allow for the necessary flexibility in method interfaces.

People are often confused when to use extends and when to use super bounds. The rule of thumb is the get-put principle. If you get something from a parametrized container, use extends.

int totalFuel(List<? extends Vehicle> list) { 
        int total = 0;
        for(Vehicle v : list) {
                total += v.getFuel();
        return total;
The method totalFuel gets Vehicles from the list, asks them about how much fuel they have, and computes the total.

If you put objects into a parametrized container, use super.

int totalValue(Valuer<? super Vehicle> valuer) {
        int total = 0;
        for(Vehicle v : vehicles) {
                total += valuer.evaluate(v);
        return total;
The method totalValue puts Vehicles into the Valuer.

It's useful to know that extends bound is much more common than super.

One more tip: if you are intimidated by wildcards (which is natural in the beginning), try to write the explicitly parametrized version first. In typical usage the two versions are equivalent. Eventually, you'll figure out when you can get rid of type parameters and use wildcards.

Read the whole article