Can someone explain the declaration of these java generic methods?

Question

I'm reading "Generics in the Java Programming Language" by Gilad Bracha and I'm confused about a style of declaration. The following code is found on page 8:

interface Collection<E> 
{ 
    public boolean containsAll(Collection<?> c); 
    public boolean addAll(Collection<? extends E> c); 
} 


interface Collection<E> 
{ 
    public <T> boolean containsAll(Collection<T> c);
    public <T extends E> boolean addAll(Collection<T> c); 
    // hey, type variables can have bounds too! 
} 

My point of confusion comes from the second declaration. It's not clear to me what the purpose the <T> declaration serves in the following line:

    public <T> boolean containsAll(Collection<T> c);

The method already has a type (boolean) associated with it.

Why would you use the <T> and what does it tell the complier?

I think my question needs to be a bit more specific.

Why would you write:

  public <T> boolean containsAll(Collection<T> c);

vs

  public boolean containsAll(Collection<T> c);

It's not clear to me, what the purpose of <T> is, in the first declaration of containsAll.

Answer 1

As far as I can tell, in this case <T> doesn't provide anything useful at all. It creates a method that is completely functionally equivalent to those using the wildcard instead.

Here are a couple of examples where it would be useful:

public List<?> transform(List<?> in);
//vs
public <T> List<T> transform(List<T> in);

In the above, you can correlate the return type with the input type. The first example cannot correlate the runtime type of the two wildcards.

public void add(List<?> list, Object obj);
//vs
public <T> void add(List<? super T> list, T obj);

In the above, the first method won't even be able to add obj to list since it can't be deemed to be type safe. The generic parameter in the second ensures that list can hold whatever type obj is.

Answer 2

The method already has a type (boolean) associated with it.

That is the return type. The full type of the method is “method that takes a Collection<T> (for some T) parameter and returns a boolean”.

And this is where T comes in: the parameter of the function uses it. In other words, this method can be called with different types as argument. The only restriction of these types is that they must implement the Collection<T> interface, which itself relies on a generic argument T (the type of the objects stored in the collection).