Ciao,
praticamente voglio creare un tipo di dati che implementi collezioni OMOGENEE e dinamica di oggetti distanziabili.
Per OMOGENEA intendo che tutti gli oggetti nella collezione devono avere lo stesso tipo effettivo. Mentre quando dico che gli oggetti devono essere distanziabili intendo dire che devono saper calcolare la propria distanza da oggetti aventi lo stesso tipo effettivo....ma il compilatore mi dà un errore che non capisco

1) Per prima cosa ho implementato un'interface che definisce cos'è un oggetto distanziabile:

codice:
public interface Distanziabile{
	double dista(Distanziabile d);		// Ogni elemento deve essere capace di calcolare la sua distanza da altri elementi
}
2) Poi definisco una collezione omogenea di generici elementi distanziabili tra loro che chiamo CollDiDistanziabili, tale classe permette di creare collezioni dinamiche di oggetti distanziabili, contiene un iteratore e permette di inserire nuovi elementi nella collezione controllando che il loro tipo sia coerente con eventuali altri oggetti già inseriti nellacollezione:

codice:
import java.util.*;

/** OVERVIEW: La classe rappresenta una collezione omogenea e dinamica di oggetti generici distanziabili tra di loro */

public class CollDiDistanziabili{
	
	private Vector V;		// La collezione viene rappresentata mediante un Vector
	
	/** EFFETCTS: Crea una nuova collezione vuota di oggetti tra loro distanziabili
		@param: void
		@return: Il riferimento ad un oggetto di tipo CollDiDistanziabili */
		
	public CollDiDistanziabili(){
		V = new Vector();				// Crea la collezione vuota
	}
	
	
	/** EFFECTS: Se la collezione è vuota, il parametro viene inserito come primo elemento della collezione;
				 Se invece la collezione non è vuota, prima di inserire il parametro nella collezione viene controllato se
				 questo è omogeneo con il tipo degli elementi presenti nella collezione, se lo è allora il parametro viene
				 inserito nella collezione mentre se non lo è viene sollevata una FailureException()
		MODIFIES: this
		@param: Il riferimento ad un oggetto di tipo Distanziabile
		@return: void */
		
	public void addDistanziabile(Distanziabile d){
		
		if(V.size() == 0) V.addElement(d);	// Se la collezione è vuota, il parametro viene inserito nella prima posizione
		
		else{	// Se invece la lista non è vuota bisogna controllare che il parametro sia omogeneo con gli altri elementi
			if(V.elementAt(0).getClass().isInstance(d))	// Se il tipo del primo elemento è lo stesso del parametro d
				V.addElement(d);						// allora inserisci d nella collezione
			else throw new FailureException();			// Se invece non lo è solleva una FailureException
		}
	}
	
	private class MioIteratore implements Iterator{		// E' la classe interna che implementa l'interfaccia Iterator
		
		private int dove;		// Variabile che indica dove ci si trova all'interno della collezione durante l'iterazione
		
		public MioIteratore(){		// Costruttore del generatore
			dove = 0;	// Imposto la variabile dove a 0 per far iniziare l'iterazione dal primo elemento della collezione
		}
		
		public Object next(){
			return V.elementAt(dove);	// Ritorna l'elemento corrente nella collezione
		}
	
		public boolean hasNext(){
			return dove < V.size();		// Se dove non è l'ultimo elemento della collezione risponde true, altrimenti false
		}
		
		public void remove(){
			dove ++;		// Rimuove l'elemento dall'iteratore (non dalla collezione) spostando dove al successivo elemento
		}
	}
	
	public Iterator enumera(){		// Maschero l'implementazione di MioIterator usando un metodo enumera
		return new MioIteratore();
	}
}
e fin quì tutto ok credo...

3) Il problema mi si pone quando vado a realizzare una classe IntPosDistanziabile che implentando l'interface Distanziabile rappresenta numeri interi positivi tra di loro distanziabili (dover per distanziabili si intende la distanza tra 2 interi, ad esempio 3 ed 1 hanno distanza 2 tra loro)

codice:
/** OVERVIEW: La classe rappresenta interi positivi distanziabili, cioè che implementino l'interface Distanziabile e che
		      quindi siano in grado di calcolare la distanza da altri elementi aventi lo stesso tipo effettivo */
		      
public class IntPosDistanziabile implements Distanziabile{
	
	int n;			// Variabile di istanza che contiene lo stato dell'ogggetto
	
	/** EFFECTS: E' il costruttore, costruisce un nuovo oggetti di tipo IntPosDistanziabile incartanto un valore intero
				 ricevuto come parametro dentro un oggetto di tipo IntPosDistanziabile; Se il parametro è positivo viene
				 creato l'oggetto, altrimenti viene lanciata una ParametroNonValidoException
		@param: Un int
		@return: Il riferimento ad un oggetto di tipo IntPosDistanziabile */
	
	public IntPosDistanziabile(int i){
		if(i >= 0) n = i;			// Se i è un parametro valido viene assegnato tale valore alla variabile di istanza
		else throw new ParametroNonTrovatoException();	// altrimenti solleva una ParametroNonTrovatoException
	}
	
	/** EFFECTS: Dice quanto l'oggetto ricevente dista dall'oggetto parametro
		@param: Il riferimento ad un oggetto di tipo IntPosDistanziabile
		@return: un valore int */
		
	public int dista(IntPosDistanziabile d){
		int dista;
		int differenza = Math.abs(this.n - d.n);
		return dista;
	}
}
Quando provo a compilare questa classe mi dà questo messaggio di errore che non capisco da cosa dipenda:

C:\Programmi\Crimson Editor\template\esercizi\esami\09-06-08>javac IntPosDistanziabile.java
IntPosDistanziabile.java:4: IntPosDistanziabile is not abstract and does not override abstract method dista(Distanziabile)
in Distanziabile
public class IntPosDistanziabile implements Distanziabile{
^
1 error

Ah i due tipi di eccezioni me li sono definiti io stupidamente in questo modo:

codice:
public class FailureException extends RuntimeException{
	
	public FailureException(){
		super();
	}
	
	public FailureException(String s){
		super(s);
	}
}
e
codice:
public class ParametroNonTrovatoException extends RuntimeException{
	
	public ParametroNonTrovatoException(){
		super();
	}
	
	public ParametroNonTrovatoException(String s){
		super(s);
	}
}
Sapete dirmi cos'è che non và? Per favore l'esame si avvicina...

Tnx