Question

Here’s an interface:

public interface Foo<T> extends Comparable<Foo<T>>  {    ... } 

And there are some classes implementing this interface:

public class Bar extends Something implements Foo<Something> {     public Vector<Foo<Bar>> giveBar() {         ...     } }  public class Boo extends SomethingElse implements Foo<SomethingElse> {     public Vector<Foo<Boo>> giveBoo() {         ...     } } 

Now I want to keep a bunch of Foos (that may really be Foos or Boos) inside a vector.

Bar bar = new Bar(); Boo boo = new Boo(); Vector<Foo<?>> vector; if (...)     vector = bar.giveBar(); else    vector = boo.giveBoo(); 

I get:

Type mismatch: cannot convert from Vector<Foo<SomethingElse>> to Vector<Foo<?>> 

The same goes for:

Vector<Foo> vector; if (...)     vector = giveBar(); else    vector = giveBoo(); 

Is a superclass that both Bar and Boo extend the only solution to this problem?

Answer 1

What all that code boils down to is:

Vector<A> vector = new Vector<B>(); 

In this case B extends A, but that’s not allowed because the types don’t match. To make clear why this doesn’t work, imagine the following code:

Vector<Vector<?>> vector = new Vector<Vector<String>>(); vector.add(new Vector<Integer>()); 

The variable’s type is of a vector of vectors of unknown type; and what’s being assigned to it is a vector of vectors of strings. The second line adds a vector of integers to that. The component type of the variable Vector<?>, which accepts Vector<Integer>; but the actual vector’s component type is Vector<String>, which doesn’t. If the compiler didn’t object to the assignment on the first line, it would allow you to write the incorrect second line without being spotted.

C#’s generics have a similar restriction, but the difference is that a generic class in C# stores it component type, while Java forgets component types when the code is compiled.

ps – Why on earth are you using Vector rather than LinkedList or ArrayList? Is it because there are threading issues involved?