Sto implementando un grafo mediante liste di incidenza, ma nel testare la classe ILDirectedGraph,
codice:
public class Prova_ILDirectedGraph {
public static void main(String[] args) {
ILDirectedGraph ildg =new ILDirectedGraph();
il compilatore mi da questo errore:
codice:
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:
codice:
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));
}
}