Question

Alright, so Java doesn’t allow the following:

Foo<?> hello = new Foo<?>();

This makes sense– after all, what’s the point of generics if you’re just gonna box/unbox everything anyways?

What’s weird, is Java does allow this:

Foo<Bar<?>> howdy = new Foo<Bar<?>>();

Granted, this actually accomplishes more, though at some point, there would be a cast to get whatever Bar is working with. But if Java is okay with some specificity, why doesn’t it allow this?:

Foo<? extends Mal> bonjour = new Foo<? extends Mal>();

The only reason I ask is I’m fixing to rely on the “wildcard inside a class parameter of a constructor”, and would seriously like to know the implications/intent behind it.

EDIT: To clarify my question, on what grounds are these statements allowed/disallowed? I’m aware that “Java doesn’t permit wildcards in constructors”, but the question is, why all this weirdness? Why aren’t bounded wildcards allowed if nested wildcards are okay?

Answer 1

As for the rationale: new Foo<?> should probably better be written as new Foo<Object>, so the compiler restriction here forces to write the code as readable as you can. The last example could likewise be new Foo<Mak>(), as there is nothing you can do on a Foo<? extends Mal> that you cannot do on a Foo<Mal>. Note that the converse isn’t true: a Foo<Mal> might accept Mal arguments where a Foo<? extends Mal> doesn’t.

On the other hand, you really might want a Foo object which can handle Bar objects of any kind, so Foo<Bar<?>> makes perfect sense. This would be the case if you only access methods of Bar which don’t rely on the type argument. There is nothing for the compiler to complain here.