Question

If I have a method, for instance

public INode getNode(final int offset);

I assume it doesn’t add something to make the method return type generic, for instance:

public <T extends INode> T getNode(final int offset);

Or did I miss something? I think generic return types are only of value if one of the parameters is of the same type (or a super/subtype)?

Answer 1

public <T extends INode> T getNode(final int offset);

Not only does this not provide any additional information to the caller, but is outright dangerous: The only way to implement that method signature is to use an unchecked cast, which can not be type safe, because a method’s type parameters are specified by its caller (explicitly or implictly through type inference), and the type parameters aren’t available to this method’s implementation. For instance, consider the following program:

class NodeCollection {
    private INode[] nodes = new INode[42];

    public <T extends INode> T getNode(final int offset) {
        return (T) nodes[offset];
    }

    public <T extends INode> setNode(final int offset, T node) {
        nodes[offset] = node;
    }
}

class ANode implements INode {}
class BNode implements INode {
    void foo();
}

public class Test {
    public static void main(String[] args) {
        NodeCollection nc = new NodeCollection();
        nc.setNode(0,new ANode());
        BNode b = nc.getNode(0); // throws ClassCastException (sic!)
    }
}

Best practice: Don’t use an unchecked cast, unless you are really sure it’ll be type correct at runtime.

I think generic return types are only of value if one of the parameters is of the same type (or a super/subtype)?

There are more cases, for instance:

public <T> T getFavorite(Class<T> clazz) {
    return clazz.cast(favorites.get(clazz));
}

or

interface List<E> {
    E get(int index);
}

or the examples in Colin’s answer, where the type variable merely appears as type parameter in the return type, which is acceptable due to type erasure.

Edit:

I think there’s no type save way if one wants to cast to the exact type of node (instead of instanceof has to precede it)

Of course there is, it’s called visitor pattern.