Difference between Enumeration<? extends ZipEntry> and Enumeration<ZipEntry>?

generics, java

Solution

There's no practical difference in terms of what you can do when you've got one of them, because the type parameter is only used in an "output" position. On the other hand, there's a big difference in terms of what you can use as one of them.

Suppose you had an `Enumeration<JarEntry>` - you couldn't pass this to a method which took `Enumeration<ZipEntry>` as one of its arguments. You could pass it to a method taking `Enumeration<? extends ZipEntry>` though.

It's more interesting when you've got a type which uses the type parameter in both input and output positions - `List<T>` being the most obvious example. Here are three examples of methods with variations on a parameter. In each case we'll try to get an item from the list, and add another one.

// Very strict - only a genuine List<T> will do
public void Foo(List<T> list)
{
    T element = list.get(0); // Valid
    list.add(element); // Valid
}

// Lax in one way: allows any List that's a List of a type
// derived from T.
public void Foo(List<? extends T> list)
{
    T element = list.get(0); // Valid
     // Invalid - this could be a list of a different type.
     // We don't want to add an Object to a List<String>
    list.add(element);   
}

// Lax in the other way: allows any List that's a List of a type
// upwards in T's inheritance hierarchy
public void Foo(List<? super T> list)
{
    // Invalid - we could be asking a List<Object> for a String.
    T element = list.get(0);
    // Valid (assuming we get the element from somewhere)
    // the list must accept a new element of type T
    list.add(element);
}

For more details, read:

- The Java language guide to generics

- The Java generics tutorial (PDF)

- The Java generics FAQ - particularly the section on wildcards

Problem

Original source