从Java中的另一个类“导入”泛型类型

Question

I am trying to represent a Graph with Nodes and Edges.

I have a class Node which has to be:

public class Node<NodeType>

and another class Edge, which I am allowed to parameterize in any way. At first I thought Edge<EdgeType> , but since they have Nodes as an atribute, I ended up doing the following (mostly because Eclipse told me about Node being a raw type if I did not parameterize it)

public class Edge<EdgeType, NodeType> {
    private Node<NodeType> start;
    private Node<NodeType> end;
    private EdgeType value;
    ...
}

This gives me the ability to work without problems in the Edge class, but there are some methods in the Node class which require working with Edges, such as

public List<EdgeType> edgesValues(Node<NodeType> node) {
    /*Returns a list of values of the edges between the node it is called on and the node given by argument*/
}

which I can't use because EdgeType is not defined. Since I cannot add another parameter in the Node class, I do not know how to "import" EdgeType into it.

Answer 1

I would put edgesValues method into a separate class that's parametrized by both NodeType and EdgeType :

class Node<N> {
    N value;
}

class Edge<E, N> {
    Node<N> from;
    Node<N> to;
    E value;
}

class Graph<E, N> {     
    Node<N> newNode(N nodeVal) {
        ...
    }

    Edge<E, N> newEdge(E edgeVal, Node<N> from, Node<N> to) {
        ...
    }

    List<E> edgesValues(Node<N> node) {
        ...
    }
}

Answer 2

If you "have a class Node which has to be" something fixed, then you should remove the EdgeType from the Edge , you aren't using it anyway:

 public class Edge<N> {
    private Node<N> start; 
    private Node<N> end;
    private int value;
 }

In your Node class, you don't need any additional type parameters now:

 public List<Edge<N>> edges(...) { ... }

You probably won't need anything more complex than int 's anyway.

Answer 3

Your solution is quite simple, use generic methods :

public <EdgeType> List<EdgeType> edgesValues(Node<NodeType> node) {

}

but passing a Node<NodeType> as parameter within a instance of Node<NodeType> doesnt make much sense - methinks you got yourself a design flaw right there, maybe you should use another design pattern