Vrftjkry

I have this simple interface:

public interface Node<E extends Node<E>>

{

    public E getParent();



    public List<E> getChildren();



    default List<E> listNodes()

    {

        List<E> result = new ArrayList<>();



        // ------> is this always safe? <-----

        @SuppressWarnings("unchecked")

        E root = (E) this;



        Queue<E> queue = new ArrayDeque<>();

        queue.add(root);



        while(!queue.isEmpty())

        {

            E node = queue.remove();



            result.add(node);



            queue.addAll(node.getChildren());

        }



        return result;

    }

}

I see that this is always an instance of Node<E> (by definition).

But I can't imagine a case where this is not an instance of E...

Since E extends Node<E>, shouldn't Node<E> also be equivalent to E by definition??

Can you give an example of an object that's an instance of Node<E>, but it's not an instance of E??

Meanwhile, my brain is melting...

The previous class was a simplified example.

To show why I need a self-bound, I'm adding a bit of complexity:

public interface Node<E extends Node<E, R>, R extends NodeRelation<E>>

{

    public List<R> getParents();



    public List<R> getChildren();



    default List<E> listDescendants()

    {

        List<E> result = new ArrayList<>();



        @SuppressWarnings("unchecked")

        E root = (E) this;



        Queue<E> queue = new ArrayDeque<>();

        queue.add(root);



        while(!queue.isEmpty())

        {

            E node = queue.remove();



            result.add(node);



            node.getChildren()

                .stream()

                .map(NodeRelation::getChild)

                .forEach(queue::add);

        }



        return result;

    }

}



public interface NodeRelation<E>

{

    public E getParent();



    public E getChild();

}

An easy example to illustrate the problem: a node of a different type of node:

class NodeA implements Node<NodeA> {

    ...

}

And:

class NodeB implements Node<NodeA> {

    ...

}

In this case, E root = (E) this would resolve to NodeA root = (NodeA) this, where this is a NodeB. And that's incompatible.

Without <E extends Node<E>>, you could have either of these cases:

Node<Integer>

where the generic type isn't a Node at all, or

Node<DifferentNode>

where the generic bounds don't match.

That said, it's not typical to see a bound this way, as Node<E> is expected to be a node that contains some value of type E, and children would be a List<Node<E>>, not a List<E>.

The problem is not in E root = (E) this. It might work well until you start iterating through result of listNodes().

That example demonstrates where exactly ClassCastException will be thrown:

public interface Node<E extends Node<E>> {



    List<E> getRelatedNodes();



    default List<E> getAllNodes() {

        List<E> result = new ArrayList<>();

        result.add((E) this); //<--that cast is not a problem because of type erasure

        return result;

    }

}



class NodeA implements Node<NodeA> {



    public NodeA() {

    }



    @Override

    public List<NodeA> getRelatedNodes() {

        return null;

    }

}



class NodeB implements Node<NodeA> {



    private List<NodeA> relatedNodes;



    public NodeB(List<NodeA> relatedNodes) {

        this.relatedNodes = relatedNodes;

    }



    @Override

    public List<NodeA> getRelatedNodes() {

        return relatedNodes;

    }

}

Execute:

List<NodeA> nodes = new NodeB(Arrays.asList(new NodeA())).getAllNodes(); //according to generic it is list of NodeA objects

for (NodeA node : nodes) { //ClassCastException will be thrown

    System.out.println(node);

}

With this sort of situation it is often useful to have a getThis method that (by convention) returns this.

I would do the following

public interface Node<E extends Node<E, R>,

                      R extends NodeRelation<E, R>>

{

    public List<R> getParents();

    public List<R> getChildren();

    public List<E> listDescendants() ;

}

public interface NodeRelation<E extends Node<E, R>,

                              R extends NodeRelation<E, R>>

{

    public E getParent();

    public E getChild();

}

abstract class ANode<E extends ANode<E,R>,

                     R extends ARelation<E,R>>

implements Node<E,R> {

    abstract protected E getThis() ;

    public List<E> listDescendants()

    {

        List<E> result = new ArrayList<>();

        E root = getThis() ;

        ...

        return result;

    }



}



abstract class ARelation<E extends ANode<E,R>,

                     R extends ARelation<E,R>>

implements NodeRelation<E,R> {

}



class CNode extends ANode<CNode, CRelation> {

    public CNode getThis() { return this ; }

    ...

}



class CRelation extends ARelation<CNode, CRelation> {

    ...

}

Although I might not bother with having both abstract class and interface layers.