Java wildcards vs type parameters

Question

Why does 1 work and 2 not ?

1:

public List<? extends Integer> l1;
public List<? extends Number> l2 = l1;

2:

public List<U> l1;
public List<S> l2 = l1;
//where U and S have been previously defined as: **S extends Number,U extends Integer**

Answer 1

Generics are not covariant. For example:

List<Integer> l1;
List<Number> l2;
l1 = l2; // incompatible types
l2 = l1; // also incompatible

However, wildcarded types offer a way to express covariance:

List<? extends Integer> l1;
List<? extends Number> l2 = l1; //legal

l1 is being expressed as a List of some unknown type that is or extends Integer. Similarly, l2 is a List of some type that is or extends Number. Since Integer extends Number, the compiler knows assigning l1 to l2 must be okay.

This situation is different:

<S extends Number, U extends Integer> void someMethod() {

    List<U> l1;
    List<S> l2 = l1; //incompatible types
}

S and U are type parameters, meaning they are provided some specific type arguments by callers of someMethod (or type inferrence). These type arguments could be a concrete type like Integer or a wildcard capture.

While they are also bounded, this is different from using bounded wildcards like above. Type parameters are bounded at declaration - within the method body they are understood not to change. For example, let's say both S and U were resolved to Integer by calling:

this.<Integer, Integer>someMethod();

In this case we can imagine the method body looks like this:

List<Integer> l1;
List<Integer> l2 = l1; // okay why not?

This would be legal, but we just happened to get lucky. There are many situations where it wouldn't be. For example:

this.<Double, Integer>someMethod();

Now we reimagine the method body:

List<Integer> l1;
List<Double> l2 = l1; // danger!

So you can see that a bounded type parameter is a something much different from a bounded wildcard, which allows different generic types to be covariantly "swapped in":

List<Integer> l1;
List<Double> l2;
List<? extends Number> l3;
l3 = l1;
l3 = l2;