Java泛型怪异行为

Question

It's hard to explain in words, but Java Generics are given me an unexpected result. I expected that if I say a list is of type ? extends Object ? extends Object , I could store anything in there. Therefore, if the list of of type Wrapper<? extends Object> Wrapper<? extends Object> , I could store any kind of Wrapper in there. And so on. That makes sense to me. But let's assume we have:

private static class Wrapper<T> {
    public Wrapper(T t) { /**/ }
}

And I want something like:

private static final List<Wrapper<Wrapper<? extends Object>>> ls1 = new ArrayList<>();

Note that this gives me an error:

public static <T> doit(T t) {
    Wrapper<Wrapper<T>> l1 = new Wrapper<>(new Wrapper<>(t));
    ls1.add(l1); // nok
    // add (Wrapper<Wrapper<? extends java.lang.Object>>) in List
    // cannot be applied to (Wrapper<Wrapper<T>>
}

But if I wrap the Wrapper in a secondary Wrapper (rs), then:

private static class C<T> extends Wrapper<Wrapper<T>> {
    public C(T t) {
        super(new Wrapper<>(t));
    }
}

private static final List<C<? extends Object>> ls2 = new ArrayList<>();

public static <T> doit(T t) {
    ls2.add(new C<>(t)); // ok
}

Note that it is the same thing; this make no sense to me.

PS. In my case, I'm not making a wrapper wrapper, but a ThreadLocal of a generic class.

Answer 1

I think

? extends Object ---> equals ?

You can do like this

List<Wrapper<Wrapper<?>>> ls1 = new ArrayList<>();

And

Wrapper<Wrapper<?>> l1 = new Wrapper<>(new Wrapper<>(t));
ls1.add(l1); // OK

Answer 2

To be honest, I would have to look into it in more detail why it does not work. Its most likely related to the generic type erasure. What I have is a workaround, I know this solution looses the typ for the l1 object. If this is ok for you take it.

Wrapper<Wrapper<? extends Object>> l1 = new Wrapper<>(new Wrapper<>(t));
ls1.add(l1);

Answer 3

Basically you need to decide what's more important, being generic over what you want to put into the wrapper, over or what you take out of the wrapper (you cannot safely both). After deciding, you will then need to choose between extends and super .

If you just want to store the pointer then List<Wrapper<Wrapper>> will suffice, but then you will need to do some casting later.

---

When you are using extends then ? extends Foo ? extends Foo means that any data type returned by the structure will a subtype of type Foo (or Foo itself).

For example if you have void doIt1( List< ? extends Mammal> l ){} you could pass in List<Human> , List<Primate> , List<Simian> or a List<Mammal> .

However when using ? extends ? extends you don't know what is safe to put in.

Consider this:

void addElephant( List< ? extends Mammal> l  ){
    l.add( new Elephant() ); //wrong!
}

This is clearly unsafe ! I could have passed in a List<Human> as l and now my list of Human s has a Elephant in it!

On the other hand you have super where ? super Foo ? super Foo means that the container can take a Foo .

So for void doIt2( List< ? extends Human> l ){} as you could pass in List<Human> , List<Primate> , List<Simian> , List<Mammal> , or a List<Object> .

void ( List< ? super Human> l  ){
    l.add( new Human() );
}

And this is fine, but you cannot guarantee anything about what you will get out of the container.

void ( List< ? super Human> l  ){
    Human h = l.get(0); //wrong!
}

That is because if l was really a List<Primate> it could have a mixture of Human s and Gorilla s and there is no guarantee that the first element will be a Human .

For this you will get the acronym PECS = "[a] P roducer ** E xtends, [but a] C onsumer S upers".

If you're container is returning object to a method (eg get ), then you are a "producing" (so use extends ), otherwise if you are accepting elements (eg add ) to a container, the container is "consuming" the object so use "super". ( Nb: tricky parts to remember about PECS is that it is from the point-of-view of the container and not the calling code!).

If you want to both produce and consume you'll need to have a concrete type list List<Primate> where you can add Human s and retrieve Primate s.

---

See also:

• What is PECS (Producer Extends Consumer Super)?
• Difference between <? super T> and <? extends T> in Java