[JAVA] Implementazione di Grafi

[lover_82]

Sto implementando un grafo mediante liste di incidenza, ma nel testare la classe ILDirectedGraph,

public class Prova_ILDirectedGraph {
  public static void main(String[] args) {
    ILDirectedGraph ildg =new ILDirectedGraph();

il compilatore mi da questo errore:

java.lang.ClassFormatError: Grafi/ILDirectedGraph (Code attribute is absent in method that is not abstract or native)

	at java.lang.ClassLoader.defineClass0(Native Method)

	at java.lang.ClassLoader.defineClass(ClassLoader.java:502)

	at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:123)

	at java.net.URLClassLoader.defineClass(URLClassLoader.java:250)

	at java.net.URLClassLoader.access$100(URLClassLoader.java:54)

	at java.net.URLClassLoader$1.run(URLClassLoader.java:193)

	at java.security.AccessController.doPrivileged(Native Method)

	at java.net.URLClassLoader.findClass(URLClassLoader.java:186)

	at java.lang.ClassLoader.loadClass(ClassLoader.java:299)

	at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:265)

	at java.lang.ClassLoader.loadClass(ClassLoader.java:255)

	at java.lang.ClassLoader.loadClassInternal(ClassLoader.java:315)

	at Grafi.Prova_ILDirectedGraph.main(Prova_ILDirectedGraph.java:5)

Exception in thread "main"

Perchè?

Questa è la mia classe ILDirectedGraph:

package Grafi;

public class ILDirectedGraph implements DirectedGraph {

  NodeList _vertices;
  NodeList _edges;

  public ILDirectedGraph() {
    _vertices = new NodeList();
    _edges = new NodeList();
  }

  public DEdge checkEdge(Edge p) {
    try {
      DEdge v = (DEdge) p;
      if (v.element() == null || v.getOrigin() == null || v.getDestination() == null)
        System.out.println("Rilevato arco non valido");
      return v;
    }
    catch (ClassCastException cce) {
      throw new InvalidPositionException("Rilevato arco non valido");
    }
  }

  public ILVertex checkVertex(Vertex p) {
    try {
      ILVertex v = (ILVertex) p;
      if (v.isNull() || v.element() == null)
        System.out.println("Rilevato vertice non valido");
      return v;
    }
    catch (ClassCastException cce) {
      throw new InvalidPositionException("Rilevato vertice non valido");
    }
  }

  public int size() {
    return _vertices.size() + _edges.size();
  }

  public boolean isEmpty() {
    return (size() < 0);
  }

  public int numVertices() {
    return _vertices.size();
  }

  public int numEdges() {
    return _edges.size();
  }

  public VertexIterator vertices() {
    return new VertexIteratorAdapter(_vertices.elements());
  }

  public EdgeIterator edges() {
    return new EdgeIteratorAdapter(_edges.elements());
  }

  public Vertex aVertex() {
    return (ILVertex) _vertices.first();
  }

  //restituisce un arco arbitrario del grafo
  public Edge anEdge() {
    return (DEdge) _edges.first();
  }

  public void reverseDirection(Edge e) {
    DEdge arcoD = checkEdge(e);
    arcoD.reverseDirection();
  }

//Setta la direzione dell'arco e uscente da v
  public void setDirectionFrom(Edge e, Vertex v) {
    DEdge arcoD = checkEdge(e);
    ILVertex vertice = checkVertex(v);
    arcoD.setDirectionFrom(vertice);
  }

//Setta la direzione dell'arco e entrante in v
  public void setDirectionTo(Edge e, Vertex v) {
    ILVertex iv = (ILVertex) v;
    DEdge arcoD = checkEdge(e);
    arcoD.setDirectionTo(v);
  }

  //Inserisce un vertice isolato nel grafo che contiene element
  public Vertex insertVertex(Object element) {
    Object obj = element;
    return ( (Vertex) _vertices.insertLast(obj));
  }

  //Inserisce un arco contenente element tra i vertici v1 e v2
  //Se il grafo è orientato v1 è l'origine e v2 è la destinazione
  public Edge insertEdge(Vertex v1, Vertex v2, Object element) {
    Vertex Vorig = v1;
    Vertex Vdest = v2;
    Object elem = element;
    DEdge arcoD = new DEdge(elem, v1, v2);
    return ( (Edge) _edges.insertLast(arcoD));
  }

  //Cancella il vertice v e tutti gli archi incidenti su esso
  public void removeVertex(Vertex v) {
    ILVertex vertice = checkVertex(v);
    _vertices.remove(vertice);
    EdgeIterator iter = inIncidentEdges(vertice);
    while (iter.hasNext()) {
      DEdge De = (DEdge) iter.nextEdge();
      _edges.remove(De);
    }
  }

  //Cancella l'arco e
  public void removeEdge(Edge e) {
    DEdge De = checkEdge(e);
    _edges.remove(De);
  }

  //Cancella l'arco tra i nodi v1 e v2
  public void removeEdge(Vertex v1, Vertex v2) {
    v1 = checkVertex(v1);
    v2 = checkVertex(v2);
    EdgeIteratorAdapter Ei = (EdgeIteratorAdapter) edges();
    while (Ei.hasNext()) {
      DEdge edge = (DEdge) Ei.nextEdge();
      if (edge.getOrigin() == v1 || edge.getDestination() == v2)
        _edges.remove(edge);
    }
  }

  //Sostituisce l'elemento in v con x
  public void replace(Vertex v, Object x) {
    ILVertex vertice = checkVertex(v);
    Object elem = x;
    _vertices.replaceElement(vertice, elem);
  }

  //Sostituisce l'elemento in e con x
  public void replace(Edge e, Object x) {
    DEdge De = checkEdge(e);
    Object elem = x;
    _edges.replaceElement(De, elem);
  }

  //Restituisce il vertice origine di e
  public Vertex origin(Edge e) {
    DEdge De = checkEdge(e);
    return (De.getOrigin());
  }

  //Restituisce il vertice destinazione di e
  public Vertex destination(Edge e) {
    DEdge De = checkEdge(e);
    return (De.getDestination());
  }

  //Restituisce il numero di archi entranti in v
  public int inDegree(Vertex v) {
    ILVertex vertice = checkVertex(v);
    return (vertice.inDegree());
  }

  //Restituisce il numero di archi uscenti da v
  public int outDegree(Vertex v) {
    ILVertex vertice = checkVertex(v);
    return (vertice.outDegree());
  }

  //Restituisce un iteratore sugli archi uscenti da v
  public EdgeIterator outIncidentEdges(Vertex v) {
    ILVertex vertice = checkVertex(v);
    EdgeIteratorAdapter Iter = (EdgeIteratorAdapter) edges();
    Edge it[] = new Edge[_edges.size()];
    int i = 0;
    while (Iter.hasNext()) {
      DEdge De = (DEdge) Iter.nextEdge();
      if (De.getOrigin() == vertice) {
        it[i] = De;
        i++;
      }
    }
    ArrayPositionIterator itera = new ArrayPositionIterator(it);
    return new EdgeIteratorAdapter(itera);
  }

  //Restituisce un iteratore sugli archi entranti in v
  public EdgeIterator inIncidentEdges(Vertex v) {
    ILVertex vertice = checkVertex(v);
    EdgeIteratorAdapter Iter = (EdgeIteratorAdapter) edges();
    Edge it[] = new Edge[_edges.size()];
    int i = 0;
    while (Iter.hasNext()) {
      DEdge De = (DEdge) Iter.nextEdge();
      if (De.getDestination() == vertice) {
        it[i] = De;
        i++;
      }
    }
    ArrayPositionIterator iterator = new ArrayPositionIterator(it);
    return new EdgeIteratorAdapter(iterator);
  }

  //Restituisce un iteratore sui vertici adiacenti a v tramite archi uscenti
  public VertexIterator outAdjacentVertices(Vertex v) {
    ILVertex vertice = checkVertex(v);
    EdgeIteratorAdapter iter = (EdgeIteratorAdapter) edges();
    Vertex it[] = new Vertex[_edges.size()];
    int i = 0;
    while (iter.hasNext()) {
      DEdge De = (DEdge) iter.nextEdge();
      if (De.getOrigin() == vertice) {
        it[i] = vertice;
        i++;
      }
    }
    ArrayPositionIterator iterator = new ArrayPositionIterator(it);
    return new VertexIteratorAdapter(iterator);
  }

  //Restituisce un iteratore sui vertici adiacenti a v tramite archi entranti
  public VertexIterator inAdjacentVertices(Vertex v);

  //restituisce true se v1 e v2 sono adiacenti
  public boolean areAdjacent(Vertex v1, Vertex v2) {
    ILVertex ve1 = checkVertex(v1);
    ILVertex ve2 = checkVertex(v2);
    EdgeIteratorAdapter iter = (EdgeIteratorAdapter) edges();
    while (iter.hasNext()) {
      DEdge De = (DEdge) iter.nextEdge();
      if ( (De.getOrigin() == ve1 && De.getDestination() == ve2) ||
          (De.getOrigin() == ve2 && De.getDestination() == ve1))
        break;
      else
        return false;
    }
    return true;
  }

  //restituisce il grado del vertice v
  public int degree(Vertex v) {
    ILVertex vertice = checkVertex(v);
    return (vertice.inDegree() + vertice.outDegree());
  }

  //restituisce un iteratore sui vertici adiacenti al vertice v
  public VertexIterator adjacentVertices(Vertex v) {
    ILVertex vertice = checkVertex(v);
    VertexIteratorAdapter Iv = (VertexIteratorAdapter) vertices();
    Vertex it[] = new Vertex[_vertices.size()];
    int i = 0;
    while (Iv.hasNext()) {
      ILVertex vi = (ILVertex) Iv.nextVertex();
      if (areAdjacent(vertice, vi)) {
        it[i] = v;
        i++;
      }
    }
    ArrayPositionIterator IterV = new ArrayPositionIterator(it);
    return new VertexIteratorAdapter(IterV);
  }

  //restituisce un array di grandezza due contenente i vertici incidenti su e
  public Vertex[] endVertices(Edge e) {
    Vertex vertici[] = new Vertex[2];
    DEdge De = checkEdge(e);
    vertici[0] = De.getOrigin();
    vertici[1] = De.getDestination();
    return vertici;
  }

  //restituisce un iteratore sugli archi adiacenti al vertice v
  public EdgeIterator incidentEdges(Vertex v) {
    ILVertex vertice = checkVertex(v);
    EdgeIteratorAdapter Iter = (EdgeIteratorAdapter) edges();
    Edge it[] = new Edge[_edges.size()];
    int i = 0;
    while (Iter.hasNext()) {
      DEdge De = (DEdge) Iter.nextEdge();
      if (De.getOrigin() == vertice || De.getDestination() == vertice) {
        it[i] = De;
        i++;
      }
    }
    ArrayPositionIterator iterator = new ArrayPositionIterator(it);
    return new EdgeIteratorAdapter(iterator);
  }

  //restituisce l'estremità di e distinta da v (l'altro vertice incidente su e)
  public Vertex opposite(Vertex v, Edge e) {
    ILVertex vertice = checkVertex(v);
    DEdge De = checkEdge(e);
    if (De.getOrigin() == vertice)
      return De.getDestination();
    else
      return De.getOrigin();
  }

  // Sostituisce l'elemento in posizione p con element
  // Restituisce l'elemento sostituito
  public Object replaceElement(Position p, Object element) throws
      InvalidPositionException {
    Object elem = element;
    if ( (_edges.replaceElement(p, elem) == null) ||
        (_vertices.replaceElement(p, elem) == null))
      throw new InvalidPositionException("non è una posizione");
    else if (_edges.replaceElement(p, elem) != null)
      return _edges.replaceElement(p, elem);
    return (_vertices.replaceElement(p, elem));
  }

  // Scambia gli elementi memorizzati nelle posizioni a e b
  public void swapElements(Position a, Position b) throws
      InvalidPositionException {
    Position p1 = a;
    Position p2 = b;
    try {
      _edges.checkPosition(p1);
      _vertices.checkPosition(p2);
      _edges.swapElements(p1, p2);
      _vertices.swapElements(p1, p2);
    }
    catch (ClassCastException cce) {
      throw new InvalidPositionException("Rilevato arco non valido");
    }
  }

  public Iterator elements() {
    int i=0;
    Object Elem[]= new Object[size()];
    VertexIterator vertici = vertices();
    EdgeIterator edge = edges();
    while(vertici.hasNext()){
      Elem[i]=vertici.nextVertex();
    }
    while(edge.hasNext()){
      Elem[i]=edge.nextEdge();
    }
    return (new ArrayObjectIterator(Elem));
  }

  public Iterator positions() {
    int i=0;
    Position Elem[]= new Position[size()];
    VertexIterator vertici = vertices();
    EdgeIterator edge = edges();
    while(vertici.hasNext()){
      Elem[i]=vertici.nextVertex();
    }
    while(edge.hasNext()){
      Elem[i]=edge.nextEdge();
    }
    return (new ArrayPositionIterator(Elem));
  }
}