[JAVA] Vari problemi a far implementare un'interface

[e-commerce84]

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:


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:


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)


/** 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:


public class FailureException extends RuntimeException{

public FailureException(){
super();
}

public FailureException(String s){
super(s);
}
}


e

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

[Ciccio17]

Nell'interfaccia hai definito il ritorno del metodo come double, nella sottoclasse come int.

Sistema questo.

[e-commerce84]

Ok...ora la mia classe è:


/** 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 double */

public double dista(Distanziabile d){
double differenza = Math.abs(this.n - d.n);
return differenza;
}
}


Però ora corretta questa cosa ora però mi trova ils eguente errore

C:\Programmi\Crimson Editor\template\esercizi\esami\09-06-08>javac IntPosDistanziabile.java
IntPosDistanziabile.java:24: cannot find symbol
symbol : variable n
location: interface Distanziabile
double differenza = Math.abs(this.n - d.n);
^
1 error

Come posso fare a dirgli di fare la sottrazione tra il valore contenuto nella variabile di istanza dell'oggetto ricevente e quello dell'oggetto parametro?

Altro dubbio avendo una signature del metodo: public double dista(Distanziabile d)

chi mi assicura che non venga invocato il metodo dista su un oggetto IntPosDistanziabile passandogli come parametro una qualche altra implementazione dell'interface Distanziabile (magari con un altro tipo effettivo come InteroPositivoPariDistianziabile ?)
Tnx

[Ciccio17]

La differenza gliela fai fare facendo:

this.n - d

Un consiglio: apri il libro e ripassa. :)

[wingman87]

Secondo me l'interfaccia che hai definito non va bene:
public interface Distanziabile{
double dista(Distanziabile d); // Ogni elemento deve essere capace di calcolare la sua distanza da altri elementi
}
Su cosa si dovrebbe basare questo metodo per calcolare la distanza tra l'oggetto da cui l'hai invocato e d?
Intendo dire che d di per sé non offre altro se non il metodo dista(), quindi nell'implementazione di questo non potrai fare riferimento ad altre proprietà o metodi a meno che tu non faccia un cast. Va bene, il cast funziona, però è molto più elegante risolverlo in un altro modo:
- O aggiungi un metodo
double posizione(); //Restituisce la posizione assoluta dell'oggetto Distanziabile
così in dista sarà possibile richiamarlo e con una differenza ottenere la distanza, senza preoccuparsi di cast. Tuttavia questo modo non mi piace molto anche se è il più generale.
- Oppure, secondo me meglio ma non sempre va bene, puoi fare come la libreria standard fa con Comparable che è definito in base a un tipo generico T:
public interface Distanziabile<T>{
public double dista(T d);
}
Così in dista non sarà necessario fare nessun cast perché si saprà a priori il tipo di d (e quindi si potranno usare direttamente tutti i suoi metodi).