Help in implementing interface

Question

I'm a newbie to Java Programming, and I'm faced with a assignment thats require me to implement in JAVA...help desperatly needed.
I post the coding which i have to implement, and this is part of the many i needed to implement. I needed to sample solution to this and I will try to get on from there. Any reply is appreciated.
package graphs;
public interface Edge {
// Returns node that this edge starts from.
// Preconditions:
// None.
// Postconditions:
// None.
public Node fromNode();
// Returns node that this edge points to.
// Preconditions:
// None.
// Postconditions:
// None.
public Node toNode();
// Set the label of this edge.
// Precondtions:
// None.
// Postconditions:
// None.
public void setLabel(Object l);
// Returns the label of this edge.
// Precondtions:
// None.
// Postconditions:
// None.
public Object getLabel();
package graphs;
public interface Node {
public void setLabel(Object l);
public Object getLabel();
e.g of calling class
// Returns unique identity of edge e in the graph.
// Preconditions:
// + The edge e must be an edge of the graph ( hasEdge(e) == true )
// => throws NoSuchEdge on violation.
// Postconditions:
// - The returned integer is in the range 0 ... numEdges() -1
// ( Result >= 0 && Result < numEdges() ).
public int id(Edge e);
// Returns the edge with unique identity id in the graph.
// Preconditions:
// + The graph must contain at least one edge ( numEdges() > 0 )
// throws NoEdges on violation.
// + id must be in the range 0..numEdges() - 1 ( id >= 0 &&
// id < numEdges() ) throws IdOutOfRange on violation.
// Postconditions
// - The returned edge is an edge in the graph ( hasEdge(Result) == true ).
public Edge getEdge(int id);
Regards

Answer 1

package graphs;
public interface Edge {
// Returns node that this edge starts from.
// Preconditions:
// None.
// Postconditions:
// None.
public Node fromNode();
// Returns node that this edge points to.
// Preconditions:
// None.
// Postconditions:
// None.
public Node toNode();
// Set the label of this edge.
// Precondtions:
// None.
// Postconditions:
// None.
public void setLabel(Object l);
// Returns the label of this edge.
// Precondtions:
// None.
// Postconditions:
// None.
public Object getLabel();
package graphs;
public interface Node {
public void setLabel(Object l);
public Object getLabel();
package graphs;
// Interface for the graph ADT.
// Design by contract style assertions are used to specify semantic
// properties for classes implementing this interface.
// In the absence of language support for assertions, implementing
// classes should check the assertions - implmenting classes extending
// the GraphBase abstract class will automatically include such checks.
// * Nodes within a graph are identified by ids that are unique for
// all nodes in that graph.
// * The ids for nodes with a graph are the integers from 0 to numNodes()-1
// inclusive.
// * A given node is a member of one and only one graph.
// * Edges within a graph are identifed by the ids of the nodes associated
// with the edge
// and by ids that are unique for all edges in that graph.
// * The ids for edges with a graph are the integers from 0 to numEdges()-1
// inclusive.
// * A given edge is a member of one and only one graph.
// * There are no relationships between graphs.
// ALTERNATIVE SPECIFICATION (DO NOT IMPLEMENT)
// * Nodes within a graph are identified by ids that are unique for all
// nodes in that graph.
// * The ids for nodes within a graph are the integers from 0 to
// numNodes()-1 inclusive.
// * A node with id x is a member of any graph having at least x+1 nodes.
// * Edges within a graph are identifed by the ids of the nodes associated
// with the edge and by ids that are unique for all edges in that graph.
// * The ids for edges with a graph are the integers from 0 to numEdges()-1
// inclusive.
// * A given edge e is a member of any graph having:
// - the two nodes associated with e as members.
// - an edge from the first of those two nodes to the second of those
// two nodes.
// * Relationships between graphs may be defined as for sets.
// END OF ALTERNATIVE SPECIFICATION
public interface Graph {
// Number of vertices (nodes).
// Preconditions:
// None.
// Postconditions:
// - The return value >= 0 ( Result >= 0 ).
public int numNodes();
// Return number of edges in the graph.
// Preconditions:
// None.
// Postconditions:
// - The return value >= 0 ( Result >= 0 ).
public int numEdges();
// Indicates whether node n is in the graph.
// Preconditions:
// + The node n is non null ( n != null ).
// Postconditions:
// None.
public boolean hasNode(Node n);
// Indicates whether edge e is in the graph.
// Preconditions:
// + The edge e is non null ( e != null ) => throws NullEdge on violation.
// Postconditions:
// None.
public boolean hasEdge(Edge e);
// Indicates whether there is an edge from node n1 to node n2 in the graph.
// Preconditions:
// + Both nodes must be in the graph ( hasNode(n1) && hasNode(n2) )
// => throws NoSuchNode on violation.
// Postconditions:
// None.
public boolean hasEdge(Node n1, Node n2);
// Returns unique identity of node n in the graph.
// Preconditions:
// + The node n must be a node of the graph ( hasNode(n) == true )
// => throws NoSuchNode on violation.
// Postconditions:
// - The returned integer is in the range 0 ... numNodes() - 1
// ( Result >= 0 && Result < numNodes() ).
public int id(Node n);
// Returns the node with unique identity id in the graph.
// Preconditions:
// + id must be in the range 0..numNodes() - 1 ( id >= 0 &&
// id < numNodes() ) throws IdOutOfRange on violation.
// Postconditions:
// - The returned node is a node in the graph ( hasNode(Result) == true ).
public Node getNode(int id);
// Returns unique identity of edge e in the graph.
// Preconditions:
// + The edge e must be an edge of the graph ( hasEdge(e) == true )
// => throws NoSuchEdge on violation.
// Postconditions:
// - The returned integer is in the range 0 ... numEdges() -1
// ( Result >= 0 && Result < numEdges() ).
public int id(Edge e);
// Returns the edge with unique identity id in the graph.
// Preconditions:
// + The graph must contain at least one edge ( numEdges() > 0 )
// throws NoEdges on violation.
// + id must be in the range 0..numEdges() - 1 ( id >= 0 &&
// id < numEdges() ) throws IdOutOfRange on violation.
// Postconditions
// - The returned edge is an edge in the graph ( hasEdge(Result) == true ).
public Edge getEdge(int id);
// Returns the edge from node n1 to node n2 in the graph.
// Preconditions:
// + Both nodes must be in the graph ( hasNode(n1) && hasNode(n2) )
// => throws NoSuchNode on violation.
// + There must be an edge from n1 to n2 in the graph
// ( hasEdge(n1,n2) == true ) => throws NoSuchEdge on violation.
// Postconditions:
// - The returned edge is in the graph ( hasEdge(Result) == true ).
public Edge getEdge(Node n1, Node n2);
// Returns number of edges from node n.
// Precondions:
// The node n is in the graph ( hasNode(n) == true )
// => throws NoSuchNode on violation.
// Postconditions:
// - The return value is in the range 0 ... number of nodes in
// the graph ( Result >= 0 && Result <= numNodes() ).
public int outDegree(Node n);
// Returns number of edges to node n.
// Precondions:
// + The node n is in the graph ( hasNode(n) == true )
// => throws NoSuchNode on violation.
// Postconditions:
// - The return value is in the range 0 ... number of nodes in the
// graph ( Result >= 0 && Result <= numNodes() ).
public int inDegree(Node n);
// Returns first node in the graph (in order of addition).
// Preconditions:
// None.
// Postconditions:
// - The returned node is null if and only if there are no nodes in
// the graph ( ( Result == null ) == ( numNodes() == 0 ) )
// - The returned node is null or is contained in the graph
// ( Result == null || hasNode(Result) == true ).
// - The returned node has an id of 0
// ( Result == null || id(Result) == 0 ).
public Node firstNode();
// Returns first edge in the graph (in order of addtion).
// Preconditions:
// None.
// Postconditions:
// - The returned edge is null if and only if there are no edges in the
// graph ( ( Result == null ) == ( numEdges() == 0 ) )
// - The returned edge is null or is an edge of the graph
// ( Result == null || hasEdge(Result) == true ).
// - The returned edge is null or has an id of 0
// ( Result == null || id(Result) == 0 ).
public Edge firstEdge();
// Returns first edge from the node, n, which is the edge from source n
// with destination node having the smallest id.
// Preconditions:
// + The node n must be a node of the graph
// ( hasNode(n) == true ) => throws NoSuchNode on violation.
// Postconditions:
// - The returned edge is null if and only if there are no edges from
// the node n ( ( Result == null ) == ( outDegree(n) == 0 ) )
// - The returned edge is null or is an edge of the graph
// ( Result == null || hasEdge(Result) == true ).
// - The returned edge is null or points from the node n
// ( Result == null || Result.fromNode() == n ).
public Edge firstEdgeFrom(Node n);
// Returns first edge to the node, n, which is the edge to destination
// n with source node having the smallest id.
// Preconditions:
// + The node n must be a node of the graph
// ( hasNode(n) == true ) => throws NoSuchNode on violation.
// Postconditions:
// - The returned edge is null if and only if there are no edges to
// the node n ( ( Result == null ) == ( inDegree(n) == 0 ) )
// - The returned edge is an edge of the graph
// ( Result == null || hasEdge(Result) == true ).
// - The returned edge points from the node n
// ( Result == null || Result.fromNode() == n ).
public Edge firstEdgeTo(Node n);
// Returns last edge from the node, n, which is the edge from source n
// with destination node having the largest id.
// Preconditions:
// + The node n must be a node of the graph
// ( hasNode(n) == true ) => throws NoSuchNode on violation.
// Postconditions:
// - The returned edge is null if and only if there are no edges from
// the node n ( ( Result == null ) == ( outDegree(n) == 0 ) )
// - The returned edge is null or is an edge of the graph
// ( Result == null || hasEdge(Result) == true ).
// - The returned edge is null or points from the node n
// ( Result == null || Result.fromNode() == n ).
public Edge lastEdgeFrom(Node n);
// Returns last edge to the node, n, which is the edge to destination
// n with source node having the largest id.
// Preconditions:
// + The node n must be a node of the graph
// ( hasNode(n) == true ) => throws NoSuchNode on violation.
// Postconditions:
// - The returned edge is null if and only if there are no edges to
// the node n ( ( Result == null ) == ( inDegree(n) == 0 ) )
// - The returned edge is an edge of the graph
// ( Result == null || hasEdge(Result) == true ).
// - The returned edge points from the node n
// ( Result == null || Result.fromNode() == n ).
public Edge lastEdgeTo(Node n);
// Returns next node in the graph after node n or null if n is the last
// node.
// Preconditions:
// + The node n must be a node of the graph
// ( hasNode(n) == true ) => throws NoSuchNode on violation.
// Postconditions:
// - The returned node is null or is contained in the graph
// ( Result == null || hasNode(Result) == true ).
// - The returned node is null if and only if the node is the node
// having the maximum id
// ( ( Result == null) == ( id(Result) == numNodes() - 1 ) ).
// - The returned node is null or the id of the returned node is
// equal to the id of n + 1
// ( Result == null || id(Result) == id(n) + 1 ).
public Node nextNode(Node n);
// Returns next edge after e or null if e is the last edge.
// Preconditions:
// + The edge e must be an edge of the graph ( hasEdge(e) == true )
// => throws NoSuchEdge on violation.
// Postconditions:
// - The returned edge is null or is contained in the graph
// ( Result == null || hasEdge(Result) == true )
// - The returned edge is null if and only if e is the edge with the
// maximum id
// ( ( Result == null) == ( id(e) == numEdges() -1 ) ).
// - The returned edge is null or the id of the returned edge is equal
// to the id of e +1
// ( Result == null || id(Result) == id(e) + 1 ).
public Edge nextEdge(Edge e);
// Returns next edge from node n after e or null if e is the last such edge.
// Preconditions:
// + The node n must be an edge of the graph ( hasNode(n) == true )
// => throws NoSuchNode on violation.
// + The edge e must be an edge of the graph ( hasEdge(e) == true )
// => throws NoSuchEdge on violation.
// + The edge e must be an edge from the node n ( e.fromNode() == n )
// => throws NoSuchEdge on violation.
// Postconditions:
// - The returned edge is null or is contained in the graph
// ( Result == null || hasEdge(Result) == true )
// - The returned edge is null or is from the node n
// ( Result == null || Result.fromNode() == n ).
// - The returned edge is null or the id of the node to which the
// returned edge points is greater than the id of the node to
// which e points
// ( Result == null || id(Result.toNode()) > id(e.toNode()) ).
public Edge nextEdgeFrom(Node n, Edge e);
// Returns next edge to node n after e or null if e is the last such edge.
// Preconditions:
// + The node n must be an edge of the graph ( hasNode(n) == true )
// => throws NoSuchNode on violation.
// + The edge e must be an edge of the graph ( hasEdge(e) == true )
// => throws NoSuchEdge on violation.
// + The edge e must be an edge to the node n ( e.toNode() == n )
// => throws NoSuchEdge on violation.
// Postconditions:
// - The returned edge is null or is contained in the graph
// ( Result == null || hasEdge(Result) == true )
// - The returned edge is null or is to the node n
// ( Result == null || Result.toNode() == n ).
// - The returned edge is null or the id of the node from which the
// returned edge points is greater than the id of the node
// from which e points
// ( Result == null || id(Result.fromNode()) > id(e.fromNode()) ).
public Edge nextEdgeTo(Node n, Edge e);
// Create and add a node to the graph with label l.
// Preconditions:
// None.
// Postconditions:
// - The number of nodes has increased by one
// ( numNodes() == old( numNodes() + 1 ) ).
// - The returned node is in the graph ( hasNode(Result) ).
// - The id of the returned node is the maximum id for any node in
// the graph ( id(Result) == numNodes()-1 ).
public Node createNode(Object l);
// Create and adds an edge from node n1 to node n2 with label l
// Preconditions:
// + Both nodes must be in the graph ( hasNode(n1) && hasNode(n2) )
// => throws NoSuchNode on violation.
// + There must not already be such an edge in the graph
// ( hasEdge(n1,n2) == false ) => throws DuplicateEdge on violation.
// Postconditions:
// - The number of edges in the graph is increased by one
// ( numEdges() == old(numEdges()) + 1 )
// - The out degree of node n1 is increased by one
// ( outDegree(n1) == old(outDegree(n1)) + 1 )
// - The in degree of node n2 is increased by one
// ( inDegree(n2) == old(inDegree(n2)) + 1 )
// - The returned edge is from node n1 and to node n2
// ( Result.fromNode() == n1 && Result.toNode() == n2 )
// - The returned edge is in the graph ( hasEdge(Result) == true )
// - The returned edge has label lbl ( Result.getLabel().equal(l) ).
// - The id of the returned edge is the maximum id for any edge in
// the graph ( id(Result) == numEdges()-1 ).
// - The returned edge is either the last edge from node n1 or the next
// edge from node n1 after the returned edge points to a node
// having an id that is greater than the id of the node that
// the returned edge points to.
// ( ( nextEdgeFrom(n1,Result) == null ) ||
// ( id((nextEdgeFrom(n1,Result)).toNode())
// > id(Result.toNode()) ) )
// - The returned edge is either the last edge to node n2 or the next
// edge to node n2 after the returned edge points from a node
// having an id that is greater than the id of the node that
// the returned edge points from.
// ( ( nextEdgeTo(n2,Result) == null ) ||
// ( id((nextEdgeTo(n2,Result)).fromNode())
// > id(Result.fromNode()) ) )
// - The returned is either the first edge from node n1 or the id of the
// node the returned edge points to is greater than the id of the
// node the first edge from node n1 points to
// ( ( firstEdgeFrom(n1) == Result ) ||
// ( id((firstEdgeFrom(n1)).toNode())
// < id(Result.toNode()) ) )
// - The returned is either the first edge from node n1 or the id of the
// node the returned edge points to is greater than the id of the
// node the first edge from node n1 points to
// ( ( firstEdgeTo(n2) == Result ) ||
// ( id((firstEdgeTo(n2)).fromNode())
// < id(Result.fromNode()) ) )
public Edge createEdge(Node n1, Node n2, Object l);
import graphs.*;
public class Printer {
private static Graph make() {
     Graph g = new GraphBase(new GraphImp());
     // Create some nodes
     Node first = g.createNode(new Integer(1));
     Node second = g.createNode(new Integer(2));
     Node third = g.createNode(new Integer(3));
     Node fourth = g.createNode(new Integer(4));
     // Create some edges between the nodes
     Edge fs = g.createEdge(first, second, new Integer(1));
     Edge ff = g.createEdge(first, first, new Integer(2));
     Edge ft = g.createEdge(first, third, new Integer(4));
     Edge ts = g.createEdge(third, second, new Integer(3));
     Edge sf = g.createEdge(second, first, new Integer(5));
     Edge s4 = g.createEdge(second, fourth, new Integer(8));
     return g;
protected static void print(Graph g) {
     System.out.println("Nodes: " + g.numNodes() + " Edges: " + g.numEdges());
     // Print graph as a list of adjacency lists.
     System.out.println("\nAdjacency lists:");
     for ( Node node = g.firstNode(); node != null ; node = g.nextNode(node) ) {
     System.out.println("Node " + g.id(node) + " has:");
     // Print the node's out edges
     if ( g.outDegree(node) == 0 ) {
          System.out.println("\tNo out edges");
     } else {
          System.out.print("\t" + g.outDegree(node) + " out edge" + (g.outDegree(node) > 1 ? "s" : "") + ":");
          for ( Edge ed = g.firstEdgeFrom(node); ed != null ; ed = g.nextEdgeFrom(node,ed) ) {
          System.out.print(" (" + g.id(ed.fromNode()) + "->" + g.id(ed.toNode()) + ":" + ed.getLabel().toString() + ")");
          System.out.println("");
     // Print the node's in edges
     if ( g.inDegree(node) == 0 ) {
          System.out.println("\tNo in edges");
     } else {
          System.out.print("\t" + g.inDegree(node) + " in edge"+ (g.outDegree(node) > 1 ? "s" : "") +":");
          for ( Edge ed = g.firstEdgeTo(node); ed != null; ed = g.nextEdgeTo(node,ed) ) {
               System.out.print(" (" + g.id(ed.fromNode()) + "->" + g.id(ed.toNode()) + ":" + ed.getLabel().toString() + ")");
          System.out.println("");
     // Print graph as an adjacency matrix.
     System.out.println("\nAdjacency matrix:");
     for(int col = 0; col < g.numNodes(); col++ ) {
     System.out.print("\t" + col);
     System.out.println("");
     for(int row = 0; row < g.numNodes(); row++ ) {
     System.out.print(row);
     for(int col = 0; col < g.numNodes(); col++ ) {
     if ( g.hasEdge(g.getNode(row), g.getNode(col)) ) {
     System.out.print("\t" + g.getEdge(g.getNode(row), g.getNode(col)).getLabel().toString());
     } else {
     System.out.print("\t-");
     System.out.println("");
     // Print graph as a list of edges
     System.out.println("\nEdge list:");
     for( int edgeId = 0; edgeId < g.numEdges(); edgeId++ ) {
     Edge edge = g.getEdge(edgeId);
     System.out.println("Edge " + edgeId + " from " + g.id(edge.fromNode()) + " to " + g.id(edge.toNode()) + " with label " + edge.getLabel().toString());
public static void main(String[] args) {
     try {
     Graph g = make();
     print(g);          
     } catch(Error e) {
     System.err.println("### Execution terminated with errors ###");
Sorry.. I think the questions that's I posted is not complete... I have input more codes to make it more complete. And many thanks to the person that replied... many thanks and hope you can reply to this. Thanks again.
I need to implement only the GraphImp class and I think it should be
public class GraphImp implements Graph, Node, Edge
Implementing Node and Edge is onl used interally in GraphImp and need not to be public.
Any help is appreciated.. and if possible... good programmers out there... please drop me an email to my problem.... million million thanks..