Java泛型之间的通配符列表和通配符框列表之间的区别？

Question

Why is

List<?> list = new ArrayList<Object>();

while at the same time

List<Box<?>> boxList = new ArrayList<Box<Object>>();

is not allowed

Also what does List<? extends Box<?>> List<? extends Box<?>> mean.

Answer 1

Because a List<Box<?>> accepts boxes containing anything. The following is thus valid:

List<Box<?>> boxes = new ArrayList<>();
boxes.add(new Box<Integer>());
boxes.add(new Box<String>());

Whereas a List<Box<Object>> only accepts instances of Box<Object> . The following is thus invalid, since a Box<Integer> and a Box<String> are not Box<Object> .

List<Box<Object>> boxes = new ArrayList<>();
boxes.add(new Box<Integer>());
boxes.add(new Box<String>());

Now if your question is "why is Box<String> not a Box<Object> " the answer is that if it were, you could do the following, which would ruin the type-safety of generic types:

Box<Integer> boxOfIntegers = new Box<>();
Box<Object> box = boxOfIntegers; // this is actually invalid
box.add("I'm a string in a box of integers. Ouch!");

Answer 2

Your question is a classic generic puzzle. Often our brain is smart enough to infer new rules from known ones, but that's not the case with generics. Your question illustrates two common problems with wildcards:

• You cannot assign a List<Box<Object>> to a List<Box<?>>
• You can actually call add() on a List<Box<?>> while you can't on a List<?>

The solution to the first problem is that generics are invariant: there's no subtype relation, no matter what types are given to the type variables, unless there are wildcards involved. Even if Box<Object> is a subtype of Box<?> the subtype relation does not hold for the enclosing lists.

The rule for problem #2 is that wildcard are not captured recursively. In fact new ArrayList<Box<?>>() is a valid expression, while new ArrayList<?>() is not. Also, as I said previously, you can add elements to a List<Box<?>> because the instatiation of the generic type List<E> yields:

// This actually doesn't compile, it's just an explanation of the
// instantiation process
public interface List<Box<?>> {
  void add(Box<?> box);
}

Answer 3

List<A> is a subtype of List<?> , where A is a type (that satisfies the bounds of the wildcard, if any).

However, List<A> is not a subtype of List<B> , if A and B are types that are different (regardless of any sub typing relationship between A and B ).

You have probably seen the case where List<String> is not a subtype of List<Object> , even though String is a subtype of Object . (I will not go into the reasons here.)

The same thing is happening where List<Box<String>> is not a subtype of List<Box<?>> , even though Box<String> is a subtype of Box<?> . Note that even though there is a ? in there somewhere, it is deep inside as part of the type Box<?> . The ? does not act at the level of the parameter of List , so it does not allow you to take different types of lists.

If you want a type that can accept List<Box<String>> and List<Box<Integer>> , etc., you may want to use List<? extends Box<?>> List<? extends Box<?>> . Note that here there is a ? at the top level. This allows the type argument of List to be any subtype of Box<?> , which includes Box<String> , Box<Integer> .