Error putting superclass objects in lower bounded wildcard list

Question

I understand that using a lower bounded wildcard on a list as method parameter should let us put elements of that lower bound and its super types but consider following code:

public class WildcardError {
    void foo(List<? super Number> i) {
        i = new ArrayList<Integer>(); //compile error
        i.add(new Integer(2)); // no error
    }
}

Now here I understand why there is a compile error in the first statement of method foo as ArrayList of Integer is not a subtype of List of "? super Number" but then why are we allowed to put Integer in this list even though integer is not a supertype of Number? Also it is the other way around in following code:

public class WildcardError {
    void foo(List<? super Integer> i) {
        i = new ArrayList<Number>(); //no error
        Number k =20;
        i.add(k); // compile error
    }
}

Here I understand there should be no compile error in statement 2 since ArrayList of Number is a subtype of List of "? super Integer" but why is there a compile error on last statement?

Even though ? super Integer should accommodate super class Number.

I've tried to find the answer but can't search the exact scenario.

Answer 1

On the first example, the lower bound ? super Number means that the actual type parameter can be either Number or a supertype (e.g. Object). Because Java's generics are invariant, a List<? super Number> can't match an ArrayList<Integer>. Remember that the lower bound is a bound on the type parameter, not on the type of arguments that may be sent as an argument. There is no error on the call to add because an Integer can be passed to the add method that may take a Number or a superclass.

On the second example, the lower bound ? super Integer means that the actual type parameter can be either Integer or a supertype (e.g. Number, Object). This matches ArrayList<Number>, so there is no error here. However, the type of i is still List<? super Integer>, which is not guaranteed to be able to take a Number such as k. It could at any time refer to a List<Integer> where a Number that could be a Double shouldn't be accepted. This is why there is a compiler error here.