StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
text
Body
copied!<p><em>Sorry, but you can't.</em></p> <p>The wildcard declaration of <code>List<? extends Number> foo3</code> means that the variable <code>foo3</code> can hold any value from a family of types (rather than any value of a specific type). It means that any of these are legal assignments:</p> <pre><code>List<? extends Number> foo3 = new ArrayList<Number>; // Number "extends" Number List<? extends Number> foo3 = new ArrayList<Integer>; // Integer extends Number List<? extends Number> foo3 = new ArrayList<Double>; // Double extends Number </code></pre> <p>So, given this, what type of object could you add to <code>List foo3</code> that would be legal after any of the above possible <code>ArrayList</code> assignments:</p> <ul> <li>You can't add an <code>Integer</code> because <code>foo3</code> could be pointing at a <code>List<Double></code>.</li> <li>You can't add a <code>Double</code> because <code>foo3</code> could be pointing at a <code>List<Integer></code>.</li> <li>You can't add a <code>Number</code> because <code>foo3</code> could be pointing at a <code>List<Integer></code>.</li> </ul> <p><strong>You can't add any object to <code>List<? extends T></code> because you can't guarantee what kind of <code>List</code> it is really pointing to, so you can't guarantee that the object is allowed in that <code>List</code>. The only "guarantee" is that you can only read from it and you'll get a <code>T</code> or subclass of <code>T</code>.</strong></p> <p>The reverse logic applies to <code>super</code>, e.g. <code>List<? super T></code>. These are legal:</p> <pre><code>List<? super Number> foo3 = new ArrayList<Number>; // Number is a "super" of Number List<? super Number> foo3 = new ArrayList<Object>; // Object is a "super" of Number </code></pre> <p><strong>You can't read the specific type T (e.g. <code>Number</code>) from <code>List<? super T></code> because you can't guarantee what kind of <code>List</code> it is really pointing to. The only "guarantee" you have is you are able to add a value of type <code>T</code> (or any subclass of <code>T</code>) without violating the integrity of the list being pointed to.</strong></p> <hr> <p>The perfect example of this is the signature for <code>Collections.copy()</code>:</p> <pre><code>public static <T> void copy(List<? super T> dest,List<? extends T> src) </code></pre> <p>Notice how the <code>src</code> list declaration uses <code>extends</code> to allow me to pass any List from a family of related List types and still guarantee it will produce values of type T or subclasses of T. But you cannot add to the <code>src</code> list.</p> <p>The <code>dest</code> list declaration uses <code>super</code> to allow me to pass any List from a family of related List types and still guarantee I can write a value of a specific type T to that list. But it cannot be guaranteed to read the values of <strong>specific</strong> type T if I read from the list.</p> <p>So now, thanks to generics wildcards, I can do any of these calls with that single method:</p> <pre><code>// copy(dest, src) Collections.copy(new ArrayList<Number>(), new ArrayList<Number()); Collections.copy(new ArrayList<Number>(), new ArrayList<Integer()); Collections.copy(new ArrayList<Object>(), new ArrayList<Number>()); Collections.copy(new ArrayList<Object>(), new ArrayList<Double()); </code></pre> <hr> <p>Consider this confusing and very wide code to exercise your brain. The commented out lines are illegal and the reason why is stated to the extreme right of the line (need to scroll to see some of them):</p> <pre><code> List<Number> listNumber_ListNumber = new ArrayList<Number>(); //List<Number> listNumber_ListInteger = new ArrayList<Integer>(); // error - can assign only exactly <Number> //List<Number> listNumber_ListDouble = new ArrayList<Double>(); // error - can assign only exactly <Number> List<? extends Number> listExtendsNumber_ListNumber = new ArrayList<Number>(); List<? extends Number> listExtendsNumber_ListInteger = new ArrayList<Integer>(); List<? extends Number> listExtendsNumber_ListDouble = new ArrayList<Double>(); List<? super Number> listSuperNumber_ListNumber = new ArrayList<Number>(); //List<? super Number> listSuperNumber_ListInteger = new ArrayList<Integer>(); // error - Integer is not superclass of Number //List<? super Number> listSuperNumber_ListDouble = new ArrayList<Double>(); // error - Double is not superclass of Number //List<Integer> listInteger_ListNumber = new ArrayList<Number>(); // error - can assign only exactly <Integer> List<Integer> listInteger_ListInteger = new ArrayList<Integer>(); //List<Integer> listInteger_ListDouble = new ArrayList<Double>(); // error - can assign only exactly <Integer> //List<? extends Integer> listExtendsInteger_ListNumber = new ArrayList<Number>(); // error - Number is not a subclass of Integer List<? extends Integer> listExtendsInteger_ListInteger = new ArrayList<Integer>(); //List<? extends Integer> listExtendsInteger_ListDouble = new ArrayList<Double>(); // error - Double is not a subclass of Integer List<? super Integer> listSuperInteger_ListNumber = new ArrayList<Number>(); List<? super Integer> listSuperInteger_ListInteger = new ArrayList<Integer>(); //List<? super Integer> listSuperInteger_ListDouble = new ArrayList<Double>(); // error - Double is not a superclass of Integer listNumber_ListNumber.add(3); // ok - allowed to add Integer to exactly List<Number> // These next 3 are compile errors for the same reason: // You don't know what kind of List<T> is really // being referenced - it may not be able to hold an Integer. // You can't add anything (not Object, Number, Integer, // nor Double) to List<? extends Number> //listExtendsNumber_ListNumber.add(3); // error - can't add Integer to *possible* List<Double>, even though it is really List<Number> //listExtendsNumber_ListInteger.add(3); // error - can't add Integer to *possible* List<Double>, even though it is really List<Integer> //listExtendsNumber_ListDouble.add(3); // error - can't add Integer to *possible* List<Double>, especially since it is really List<Double> listSuperNumber_ListNumber.add(3); // ok - allowed to add Integer to List<Number> or List<Object> listInteger_ListInteger.add(3); // ok - allowed to add Integer to exactly List<Integer> (duh) // This fails for same reason above - you can't // guarantee what kind of List the var is really // pointing to //listExtendsInteger_ListInteger.add(3); // error - can't add Integer to *possible* List<X> that is only allowed to hold X's listSuperInteger_ListNumber.add(3); // ok - allowed to add Integer to List<Integer>, List<Number>, or List<Object> listSuperInteger_ListInteger.add(3); // ok - allowed to add Integer to List<Integer>, List<Number>, or List<Object> </code></pre>

Querying!

Guidance

An individual column

Larger individual text columns get their own page to allow for proper reading.

SQuiL has stopped working due to an internal error.

If you are curious you may find further information in the browser console, which is accessible through the devtools (F12).

Reload