Java泛型：有界通配符破坏日食

Question

There is an external interface named Shape (name changed, but you get the idea).

I have a class that has a constructor that takes

Collection<? extends Shape>

This class is under test. I am writing the unit tests. I want to create a Collection that extends Shape to provide to the constructor.

I notice that no class in our project implements Shape, so I write an inner class:

private class TestShape implements Shape {
    private static final long serialVersionUID = 1L;

    @Override
    public String getAuthority() {
        return "Foo";
    }
}

Then I try to create my Collection ...

private ArrayList<? extends Shape> shapes;
shapes = new ArrayList<Shape>();
shapes.add(new TestShape());

Eclipse however is unhappy with me ...

The method add(capture#1-of ? extends Shape) in the type ArrayList<capture#1-of ? extends Shape> is not applicable for the arguments (Test.TestShape)

Why?

edit: Lots of editing because generics syntax makes SO unhappy

Answer 1

Let's imagine that we have TestShape implements Shape , and EvilShape also implements Shape . Now imagine the following:

private ArrayList<? extends Shape> shapes; //OK
shapes = new ArrayList<EvilShape>(); // OK
authorities.add(new TestShape()); // Type safety issue

Clearly, such a thing won't work. Instead, do the following:

private ArrayList<Shape> shapes; //OK
shapes = new ArrayList<Shape>(); // OK
authorities.add(new TestShape()); // OK

Or the following:

private ArrayList<? super Shape> shapes; //OK
shapes = new ArrayList<Shape>(); // Or, for that matter, an `ArrayList<Object>`.
authorities.add(new TestShape()); // OK

This will work, as you can add a subclass/implementation of Shape to a List<Shape> . Using an exact type parameter and not a wildcard will prevent the following:

private ArrayList<Shape> shapes; //OK
shapes = new ArrayList<EvilShape>(); // DANGER! Java does not allow this

The abbreviation PECS helps remember this: Producer Extends, Consumer Super. This comes from Joshua Bloch's Effective Java .

Answer 2

I have a class that has a constructor that takes

 Collection<? extends Shape> 

...

Then I try to create my Collection ...

 private ArrayList<? extends Shape> shapes; 

I think one thing that may be confusing is that just because there is a method parameter like that ( Collection<? extends Shape> ), you don't need to create a variable like that. Think of the purpose of a variable/parameter that uses wildcard generics (? extends X or ? super Y) as a way to write some "generic" code that will work with any value from a family of similar types rather than the usual "a value from a specific type".

--

The perfect example of this is the signature for Collection.copy():

public static <T> void copy(List<? super T> dest,List<? extends T> src)

This method allows me to pass an instance of List<Integer> and have its values copied into an instance of List<Number> . It also allows me to copy List<Integer> into List<Integer> . It lets me use the same code with different types ("family of types"). I can test it with using wildcard generic variables at all:

List<Integer> src = new ArrayList<>();
src.add(1);
List<Number> dest = new ArrayList<>();

Collection.copy(src, dest);

assert(src.get(0), dest.get(0));

--

The big tradeoff with using a variable or parameter like List<? super T> List<? super T> or List<? extends T> List<? extends T> is that because its not a variable for a specific type, there are limitations on what you can assume about the instance it points to and therefore you are limited in what you can do with it.

PECS is a tiny bit of an oversimplification, but it makes a great mnemonic: PECS = "producer extends, consumer super" means that a variable (or parameter) for a generic wildcard type that uses extends can only be used to "produce" values, ie you can safely only read from it, you can't add to it. Similarly, a variable for a generic wildcard type that uses super can only be used to "consume" values - you can safely only feed it values (add), but there are limitations on what you can assume about the values that could be "read" from it.

So, for your example, I would avoid using a variable with a wildcard generic at all, just pass in different List<> types to the constructor. If you must use a variable with a wildcard generic, that use a variable to the specific type to fill it because the variable with the wildcard generic that uses extends can't be used to fill it:

private ArrayList<Shape> shapesSpecific;
private ArrayList<? extends Shape> shapesExtends;
shapesExtends = shapesSpecific = new ArrayList<Shape>();

shapesSpecific.add(new TestShape());   // fine
//shapesExtends.add(new TestShape());  // error - but the line above added a value already

// Another option - create it already filled:
// shapeExtends = Arrays.asList(new TestShape());

new Foo(shapesSpecific);  // fine
new Foo(shapesExtends);   // fine

--

You might find this question/answer useful:

How can I add to List<? extends Number> data structures? - here's an example from it:

The wildcard declaration of List<? extends Number> foo3 List<? extends Number> foo3 means that the variable foo3 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:

 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 

So, given this, what type of object could you add to List foo3 that would be legal after any of the above possible ArrayList assignments:

• You can't add an Integer because foo3 could be pointing at a List<Double> .
• You can't add a Double because foo3 could be pointing at a List<Integer> .
• You can't add a Number because foo3 could be pointing at a List<Integer> .

You can't add any object to List<? extends T> List<? extends T> because you can't guarantee what kind of List it is really pointing to, so you can't guarantee that the object is allowed in that List . The only "guarantee" is that you can only read from it and you'll get a T or subclass of T .

This is a similar question/answer:

Difference between <? super T> and <? extends T> in Java

Answer 3

If this is for a unit test, just make a collection of Shapes:

import java.util.ArrayList;
import java.util.Collection;

public class test {
    public interface Shape {
        String getAuthority();

    }

    private static class TestShape implements Shape {

        @Override
        public String getAuthority() {
            return "Foo";
        }
    }

    public static void method(Collection<? extends Shape> shapes){

    }

    public static void main(String ... args){
        ArrayList<Shape> shapes;
        shapes = new ArrayList<Shape>();
        shapes.add(new TestShape());
        method(shapes);
    }
}

this compiles cleanly and is likely how the method is used in actual practice.