Generics with recursive parameters

Question

Hi all,
I'm developing a class hierarchy using generics for representing graphs in our product. I end up with a lot of types such as:
public interface Node< T extends Node<T> >
  Set< Port<N> > getPorts();
public interface Port< T extends Node<T> >
  etc etc
}which has caused me to run into the following bugs:
http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6548436
http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6507317
When I first started working with the hierarchy, I had a lot of code of the form:
Set< Port< ? extends Node<?> > > = node.getPort();which triggered the above bugs all over the place. I've since found that I can use the shorter form:
Set< Port<?> > = node.getPort();and it seems to just work. My question is: is this the same thing? Is the compiler smart enough to work out that the wildcard in Port<?> is really a T extends Node<T> because it's declared that way in the original class?
Thanks for any help,
Colin

Answer 1

public class Graph implements Map<String, Node>, Map<String, Edge> {The problem is that after compilation, when the object code is produced, any "type parameter" information is erased (you need to read up on Java reflection more closely).
Thus, there is only one Map class in the runtime (not one for every possible combination of type parameters). and any references to, say, Map<String,Node>.put() become, at runtime, just Map.put().
So you can't do what you want, because at compile time, your two parent interfaces are "different", but at runtime, they would be the same. The message could be better, I agree.
To do what you want:
* If your two classes (Edge and Node) have no relationship to each other, then you'll have to implement Map<String,Object>.
* If they do have a common ancestor, you can declare it as extending Map<String,CommonAncestor>.
In both cases, you'll have to, e.g. downcast the result of get() to the right type.