Does wildcard refer to a superclass like Object or a subtype like Integer?

Question

This was closed as being a duplicate of the PECS question. PECS is just a mnemonic that does more harm than good because people just memorize it without really understanding the deeper issues. Please reopen.

Update:

What I understood from @rzswitzerloot's explanation below is: the wildcard just refers to the type of element in the Array. It does not mean one can add the wildcard type to the array - in fact, one can only add descendants of the type (including itself, in this case, 'B').

I am confused by whether wildcards <? super Number> refers to a superclass like Object or a subtype like Integer. In "Java OCP 17 Developer Complete Study Guide" by Jeanne Boyarsky and Scott Selikoff, (Chapter 9 Collections and Generics)

Generics allow you to specify wildcards. <?> is an unbounded wildcard that means any type. <? extends Object> is an upper bound that means any type that is Object or extends it. <? extends MyInterface> means any type that implements MyInterface. <? super Number> is a lower bound that means any type that is Number or a super class. A compiler error results from code that attempts to add an item in a list with an unbounded or upper-bounded wildcard

A super class as I understand, is a parent of Number. But then, why cannot one do this?

import java.util.ArrayList;
import java.util.List;

public class Bewildered {
    static class A {}
    static class B extends A {}
    static class C extends B {}

    public static void main(String[] args) {
        List<? super B> listBs = new ArrayList<>();
        listBs.add(new A());
    }
}

compile error:

java: incompatible types: Bewildered.A cannot be converted to capture#1 of ? super Bewildered.B

The documentation you've included seems pretty clear on the subject. ` super Number>` would apply to `Object`, as its a superclass of `Number`. — CryptoFool, Sep 29 '22 at 02:05
"` super Number>` is a lower bound that means any type ***that is Number*** or a super class" See that part? It doesn't necessarily have to be a superclass. `? super B` could be `B`, in which case adding an `A` is not allowed. — Sweeper, Sep 29 '22 at 02:16
@Sweeper I understand that it can take B. But why can't it take A? I tried and it gives a compile error. — likejudo, Sep 29 '22 at 03:02
It does answer the question. I and others repeatedly explained to you in the comments why it answers the question. This is not a discussion forum; "I need the same material explained in a different way in order to understand it" is not a reason to have a separate question. — Karl Knechtel, Sep 29 '22 at 03:09
"I understand that it can take B. But why can't it take A?" **For the reason carefully and repeatedly explained in the duplicate that was linked to you last time, and repeatedly re-stated in the comment discussion that ensued there**. — Karl Knechtel, Sep 29 '22 at 03:10

score 3 · Answer 1 · answered Sep 29 '22 at 02:10

3

Because you're thinking about what generics means in the wrong way.

List<? super B> does not mean: "A list that contains Bs or anything that is a supertype of B".

Because that would be utterly useless. Object is a supertype of B. All things are objects. So it's a list of absolutely anything, there's absolutely nothing useful about this list.

No, what List<? super B> means: There is a type. A specific type. It's just.. this code doesn't know what it is. We do know that it is either B or some supertype of B. (So, it's B, or A, or Object, we don't know. The caller picked one of these 3 types). This list is constrained; it cannot contain anything that is not this unknown type.

The point is, you can do this:

List<B> bees = new ArrayList<B>();
List<? super B> list = bees; // legal!
list.add(new A()); // um...
B bee = bees.get(0); // oh no!

See how this goes wrong? There's only one list here - bees and list are both just variables that refer to the exacrt same list. So you if you call list.add, you're modifying the one list that both bees and list are pointing at, so you also add it to bees.

So what's the point of <? super B>?

You can call .add(new B()). Because that works for all legal choices. Whatever the caller picked - if they gave you a List<B>, it works. If it's a List<A>, works. List<Object>? Still acceptable.

No other types fit the bill for <? super B>, so we've exhausted the options: They all 'work out'.

answered Sep 29 '22 at 02:10

rzwitserloot

85,357
5
51
72

2

"So it's a list of absolutely anything, there's absolutely nothing useful about this list." A list of `Object` is useful; it stores stuff. What would be useless is the type bound, if it worked that way (since it would be equivalent to just writing `List` without any `<>`). – Karl Knechtel Sep 29 '22 at 02:13
2

BTW: OP was already linked to the canonical duplicate for this question a couple of weeks ago, got in a protracted argument, insisted the canonical duplicate meant the opposite of what it actually said (seemingly due to the misconception you describe here), and eventually that question was deleted. – Karl Knechtel Sep 29 '22 at 02:16
3

I am not a moderator at all. I am voting the close the question, as part of a democratic process, because it is supposed to be closed according to the site standards. The linked duplicate explains the answer, and we went through many more comments trying to explain it to you as well. To be quite honest, you come across as refusing to accept explanations, and instead trying to say that the compiler, along with everyone else is wrong and you are right, based on your misunderstanding of what it says in a book (which actually agrees with us and with the compiler). – Karl Knechtel Sep 29 '22 at 03:08
@rzwitserloot Thanks for your reply. I am trying hard to understand before the question is closed and deleted by some people. Are you saying that List.add(new B()), List.add(new B()), List – likejudo Sep 29 '22 at 03:16
1

Yes, of course that would work. Trivially. `Object c = new B();` works, and obviously `List – rzwitserloot Sep 29 '22 at 03:22
@rzwitserloot `List super B> aList = new ArrayList(); aList.add(new A());` I am surprised that even if we have an `ArrayList ` we cannot add an `A` to it? This too does not compile. – likejudo Sep 29 '22 at 23:41
2

You don't have an `ArrayList`. You have an expression of type `List super B>`. The __compiler__ does not know it's _currently_ pointing at an `ArrayList `. – rzwitserloot Sep 30 '22 at 01:23
@rzwitserloot I am still puzzled by the statement "The compiler does not know it's currently pointing at an ArrayList." We are assigning an `ArrayList ` to aList which is a `List super B>`. It seems to me the compiler should know. – likejudo Oct 03 '22 at 16:52
@rzwitserloot Does `List super B>` means every member should be the same (all As, OR all Bs, OR all Objects) when it is created? – likejudo Oct 04 '22 at 00:52
But the compiler knows that we are only adding an A to a List yet it disallowed it! – likejudo Oct 04 '22 at 00:59
@likejudo you seem like you don't understand the difference between compile-time and write-time. `List super B>` is a variable type. You can't make such a thing. You can _assign_ a `List` to such a variable, or a `List`, or even a `List – rzwitserloot Oct 04 '22 at 01:53
@rzwitserloot What I understood from your explanation is: the wildcard just refers to the type of element in the Array. It does not mean one can add the wildcard type to the array. – likejudo Aug 08 '23 at 15:40
@rzwitserloot ...continued In fact, one can only add descendants of the type (including itself, in this case, 'B'). – likejudo Aug 08 '23 at 15:40
No, the compiler does not keep track of what you last assigned to it. Because that's mostly pointless - in this academic code, sure, but imagine instead we have: `public List super B> makeAList() { return new ArrayList(); }` and we write `List super B> = makeAList();` - if the compiler still 'tracks' that it really is an `ArrayList ` so just allow `List super B> list = makeAList(); list.add(new A())` - then what happens if the author of `makeAList` updates their code and releases a new version that now makes a `new ArrayList`? – rzwitserloot Aug 08 '23 at 17:51
The whole point of being explicit about having to write types (for local variables, but _especially_ for method return and param types) is that you reserve the right to change implementation details later as long as the types still work out. If you want the compiler to infer everything, there is no point to having a language where you write types explicitly. – rzwitserloot Aug 08 '23 at 17:52

Does wildcard refer to a superclass like Object or a subtype like Integer?

1 Answers1