Question

If you wanted to store an array of objects of type MyInterface, are the following both acceptable and if so when would you use the second form over the first?

i) Using only an interface:-

List<MyInterface> mylist = new ArrayList<MyInterface>();

ii) Using a generic wildcard:-

List<? extends MyInterface> mylist = new ArrayList<? extends MyInterface>();

Edit:

As the answers so far have pointed out, number ii won’t compile. What is the difference between i and a case iii where :-

iii) Using a generic wildcard only in the reference:-

List<? extends MyInterface> mylist = new ArrayList<MyInterface>();

Answer 1

Second one won’t compile. Imagine:

A implements MyInterface
B implements MyInterface

Then the following would match your second expression, but won’t compile:

// incorrect
List<A> mylist = new ArrayList<B>();

Correction: Wrong one too:

List<? extends MyInterface> mylist = new ArrayList<MyInterface>();

It is right in a sense it does compile, but you cannot add any subclasses of MyInterface to it. Confusing, but correct — after I read the explanation. Same reason: wildcard can be viewed for example as:

// I know this is not compileable; this is internal compiler "thinking".
// Read it as "somewhere someone may instantiate an ArrayList<A> and pass 
// it down to us; but we cannot accept it as something that could be 
// potentially used as List<B>"
List<A> mylist = new ArrayList<MyInterface>();

So this won’t work:

mylist.add(b);

and vice versa. Compiler refuses to do those potentially incorrect operations.

The option which allows you to add any subclass of MyInterface to mylist is:

List<MyInterface> mylist = new ArrayList<MyInterface>();