9

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.

Improve this question
3
  • 1
    If you understand the PECS then you will understand these. Check here stackoverflow.com/questions/4535930/… Commented Jan 14, 2011 at 15:17
  • 1
    In the Oracle/Sun JDK 6, the first example is used, so I don't know you would use the second either. Commented Jan 14, 2011 at 15:18
  • 1
    And why is it better than public boolean containsAll(Collection<?> c);? Commented Jan 14, 2011 at 15:26

6 Answers 6

Reset to default
3

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.

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

3

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).

Improve this answer

4 Comments

But why is this better than the seemingly functional equivalent public boolean containsAll(Collection<?> c)? Similarly why not public boolean addAll(Collection<? extends E> c)?
It's better because the body or definition of the method can refer to the type T, and the code can avoid casting and be guaranteed type-safe by the compiler. See my answer for further explanation.
@Dave Costa: I don't see an answer from you, but whether using <T> helps other methods is irrelevant. We're talking about these methods, where it doesn't seem to provide any benefit.
@Mark -- just finished my answer. Yeah, you're right that it doesn't make any difference in these method declarations -- although potentially that T parameter could be referenced in the body of an implementation. But I read the original question as being more general.
2

The ? is simply a wildcard. It means that the method will accept a Collection of any type.

The <T> is a type parameter for the method. It is essentially assigning the wildcard a name which can then be referred to elsewhere in the method declaration and definition.

A better illustration of the difference would be if the return type of the method varied based on the type that was passed in.

Say you started with a method like

Object getRandomElement( Collection<?> c )

This will accept any Collection, but there's no way to constrain its return type. So a caller would have to cast the result back to whatever type it expected -- which should work, but raises unsafe type-conversion warnings.

With a type parameter you would instead write

<T> T getRandomElement( Collection<T> c )

In this case, if you call this method with a Collection<String>, the compiler knows that it will return a String.

Improve this answer

1 Comment

Well said. I think a good rule of thumb is that the type parameter is only required when you either have a parameterized return type (like Collections.emptyList()) or when you need to correlate the return type or another parameter with a parameterized or generic parameter.
1

<T> as used here (in method declaration, before return type) is a generic type declaration. You can define new generic type for use within a method: http://download.oracle.com/javase/tutorial/java/generics/genmethods.html

Improve this answer

Comments

0

Try compiling it without the <T>.

Basically, it's telling the compiler that this method contains a generic. It isn't required in the first example because ? is a special case, and the second method is referencing the type defined in the Interface itself.

On an unrelated note, public is not required in an Interface. Methods in an interface are public by default, so can save you a bit of typing.

Improve this answer

Comments

0

It declares the generic type T used by the method. While the generic type E is the same for the whole interface T is limited to the method it is declared for.

Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.