Java泛型中的通配符

Question

I know Generics are invariant: for any two distinct types Type1 and Type2, List< Type1> is neither a subtype nor a supertype of List< Type2>

so

List<someObject> nums = new ArrayList<someObject>(); // this is correct
List<Object> nums = new ArrayList<subObject>(); // this is  not correct

but

List<Number> nums = new ArrayList<Number>();
List<? super Number> sink = nums;   ????(line 2)

let say if wildcard is Object so line 2 wil be

List<Object> sink = List<Number> nums 

It seems that the invariant rule not applied here

can anyone explain to me why line 2 is compiled without error ?

Thank so much

Answer 1

If I am not wrong, you wish to have an explanation on how is the below valid code:

List<Number> nums = new ArrayList<Number>();
List<? super Number> sink = nums;

Invariance is property of the class on how its type parameter affects its subtyping.

Generics are invariant, but wild cards exist to help us with with sub-typing. They are not very useful as they dont representing anytype but represent a good hack. Below is valid

List<Animal>  <: List<?>
List<?>       <: List

Better example:

List<? super Animal> d1= new ArrayList<Animal>();
d1.add(new Animal());
d1.add(new Dog());

The above works, because d1 is of type List<? super Animal> List<? super Animal> . You can imagine add function to behave like:

boolean add(? super Animal e);

So to add method you can pass any variable that is subtype of ? super Animal ? super Animal . And

Animal <: ? super Animal
Dog    <: ? super Animal

So adding a Dog or Animal works. So d1 acts as a list that can take any parameter of type Animal or subtype if it.

Similarly, you can also have below. But technically you cant add anything to this list. If there existed sometype in java that is subtype of every type, then you could properly add element of that type to it. Nothing Else.

ArrayList<? extends Animal> d1  = new ArrayList<Animal>();

Look at this answer for more info .

Answer 2

The invariant rule does indeed apply. The statement:

List<? super Number> sink = nums; 

just doesn't work they way you are thinking.

I expect that you think that you can assign an object of type ArrayList to a variable of type List<? super Number> List<? super Number> because the former is a subclass of the latter. This would break the invariant rule, but this is not what is happening.

The List<? super Number> List<? super Number> variable represents the set of all possible List where someClass is Number or is an ancestor of Number.

let say if wildcard is Object so line 2 wil be

  `List<Object> sink = List<Number> nums ` 

In this context the ? doesn't get set arbitrarily, so this doesn't happen.

Answer 3

Lets have:

List<Integer> li = new ArrayList<>();
List<Object> lo = new ArrayList<>();
l = lo;//not allowed
lo.add("string");
Integer i = li.get(0);//that is string there

That is why you cannot make such assignment. I think compiler doesn't treat direct assignment of new ArrayList<Integer>() other then existing variable li .