Bounds

    class EmployeeList< T extends Employee > { ... }

    class EmployeeList< T extends Employee & Ranked & Printable > { ... }

The order of the & interface bounds is not significant, but only one class type can be specified and if there is one, it must come first. When a type has no specific bounds, the bound extends Object is implicit.

By applying bounds to our type, we not only limit the instantiations of the generic class, but we make the type arguments more useful. Now that we know that our type must extend some type or implement some set of interfaces, we can use variables and arguments declared with T by those other type names. Here is a somewhat contrived extension of our previous example:

    class EmployeeList< T extends Employee & Ranked & Printable >
    {
        Ranked ranking;
        List<Printable> printList = new ArrayList<Printable>();

        public void addEmployee( T employee ) {
            this.ranking = employee;  // T as Ranked
            printList.add( employee );  // T as Printable
        }
    }

This example shows that by placing bounds on the generic parameter type we can require it to be of a particular class type or implement certain interface types. This allows us to use arguments of the parameter type passed to methods in more useful ways. In this example, we know that the EmployeeList will be instantiated with a generic type that is a Printable and so we can use the employee argument as a Printable.

Type variables can also refer to other type variables within the type declaration:

    class Foo <A, B extends A> { ... }

We’ll see a particularly vicious example of this later when we talk about the definition of the Enum class. We’ll also see a more convenient technique for declaring how individual elements of a generic class relate to the parameter type when we cover wildcards in the next section.