e-commerce84
07-06-2009, 17:50
Ciao,
vi prego di aiutarmi...domani esame....mi sono impicciato con questo esercizio d'esame dove c'è la reflection
Si consideri una collezione di oggetti generici e misurabili che sia omogenea (ovvero, tutti gli oggetti nella collezione sono dello stesso tipo), dinamica (ovvero, è possibile inserire e rimuovere oggetti dalla collezione) e dotata di un metodo in grado di accedere ai suoi elementi.
Si consideri un metodo cercaElemento che prende in input una tale collezione generica di oggetti C ed un oggetto obj, e cerca se nella collezione C è presente un oggetto la cui misura è uguale a quella di obj: in caso positivo il metodo restituisce l’indice di un oggetto la cui misura è uguale a quella di obj, altrimenti
a) se C contiene almeno un elemento la cui misura è minore a quella di obj, allora il metodo restituisce la lista degli elementi la cui misura è minore a quella di obj (in una forma ascelta), altrimenti
b) il metodo segnala che nessuna delle due eventualità precedenti è verificata.
Problema 1. Si richiede la progettazione del tipo di dati CollezioneOggettiMisurabili corrispondente alle specifiche sopra descritte e di tutti i tipi coinvolti, nonché la loro
implementazione in linguaggio Java. Per la classe CollezioneOggettiMisurabili si richiede la funzione di astrazione e l’invariante di rappresentazione.
Problema 2. Si richiede l’implementazione in linguaggio Java del metodo cercaElemento.
Io l'ho pensato così, ma mi impiccio in un punto e non sò che fare:
Per prima cosa definisco un'interface Misurabile che definisce dei generici oggetti misurabili che hanno in comune la capacità di misurarsi e di restituire tale valore.
public interface Misurabile{
/** OVERVIEW: Definisce oggetti misurabili ed implementa un metodo misura() */
double misura();
}
Poi definisco una classe chiamata CollezioneDiOggettiMisurabili che implementa la collezione in modo tale che contenga solo elementi aventi tutti lo stesso tipo effettivo e che implementa le 3 operazioni richieste: inserimento di un oggetto nella collezione (viene inserito se e solo se ha lo stesso tipo effettivo degli altri oggetti eventualmente presenti nella collezione), rimozione di un oggetto dalla collezione ed accesso ad un elemento della collezione.
Proprio l'implementazione dell'ultimo metodo mi stà creando non pochi problemi e credo che bisogna usare la reflection (che abbiamo trattato l'ultima lezione molto velocemente).
Questa è la mia classe, il metodo get() non riesco ad implementarlo del tutto:
import java.util.*;
import java.lang.*;
public class CollezioneOggettiMisurabili{
/** OVERVIEW: Rappresenta una collezione omogenea (tutti gli elementi appartenenti alla collezione devono avere lo stesso
tipo effettivo) di generici oggetti Misurabile
V = {{m_1, m_2, m_3,......., m_n} dove per ogni m_i è un oggetto misurabile}
O = 1) Inserisci() : Inserisce un oggetto nella collezione
2) Elimina(): Elimina un elemento dalla collezione
3) get(): Accede ad un determinato elemento della collezione
C = 0 (non ci sono costanti significative
F_a(): STATO CONCRETO -----> STATO ASTRATTO
F_a([3, 5, 8]) ------> {{3, 5, 8}, che sono oggetti InteriMisurabili}
I(oggetto): 1) oggetto.collezione != null (la collezione non deve mai essere null)
2) Per ogni i oggetto.get(i) è un Misurabile (tutti gli oggetti della collezione devono essere dei Misurabile)
3) Per ogni i oggetto.get(i) deve avere lo stesso tipo effettivo di tutti gli altri elementi della collezione
*/
private Vector collezione; // Per rappresentare la collezione di oggetti misurabili
/** COSTRUTTORE:
EFFECTS: Costruisce un nuovo oggetto di tipo CollezioneOggettiMisurabili che rappresenta la collezione vuota
@param: void
@return: Il riferimento ad un nuovo oggetto di tipo CollezioneOggettiMisurabili */
public CollezioneOggettiMisurabili(){
collezione = new Vector(); // Crea la collezione vuota
}
/** inserisci():
EFFECTS: Se possibile inserisce un nuovo oggetto all'interno della collezione. Se la collezione è vuota, l'oggetto
passatogli come parametro viene inserito nella prima posizione della collezione; Se invece la collezione
non è vuota, il parametro verrà inserito nella collezione se e solo se ha lo stessotipo effettivo degli
altri elementi appartenenti alla collezione
MODIFIES: this
@param: Il riferimento ad un oggetto di tipo Misurabile
@return: void */
public void inserisci(Misurabile m){
if(collezione.size() == 0) // Se la collezione è vuota
collezione.addElement(m); // Inserisce l'oggetto referenziato dal parametro in prima posizione
else{ // Se invece la collezione non è vuota
// Controlla che l'oggetto referenziato dal parametro abbia lo stesso tipo effettivo degli oggetti nella collezione
if(collezione.elementAt(0).getClass().isInstance(m)) // Se è vero
collezione.addElement(m); // Inserisce l'oggetto referenziato dal parametro in prima posizione
else throw new FailureException(); // Se invece non lo è solleva una FailureException
}
}
/** rimuovi():
EFFECTS: Se possibile rimuove l'i-esimo elemento dalla collezione, non è possibile rimuovere un elemento avente
posizione negativa o maggiore della dimensione della collezione
REQUIRES: La collezione non deve essere vuota ed il parametro che indica la posizione dell'elemento da rimuovere
deve essere >=0 e < della dimensione della collezione
@param: int indica la posizione dell'elemento da rimuovere
@return: void */
public void rimuovi(int i){
if(i >= 0 && i <= collezione.size() && collezione != null) // Se possibile rimuovi l'elemento lo rimuove
collezione.remove(i);
else throw new FailureException(); // Se invece non lo è solleva una FailureException
}
/** get():
EFFECTS: Se possibile restituisce l'i-esimo elemento dalla collezione, non è possibile restituire un elemento avente
posizione negativa o maggiore della dimensione della collezione
REQUIRES: La collezione non deve essere vuota ed il parametro che indica la posizione dell'elemento da restituire
deve essere >=0 e < della dimensione della collezione
@param: int indica la posizione dell'elemento da restituire
@return: Un oggetto di tipo Misurabile */
public Misurabile get(int i){
if(i >= 0 && i <= collezione.size() && collezione != null) // Se possibile restituire l'elemento lo restituisce
return collezione.elementAt(i);
else throw new FailureException(); // Se invece non lo è solleva una FailureException
}
}
Inizialmente il metodo get lo avevo implementato così ma poi compilando mi sono reso conto che è sicuramente sbagliato in quanto credo che il metodo elementAt restituisca un Object o comunque un generico Misurabile (confermate?) ed infatti il compilatore mi da questo errore:
C:\Programmi\Crimson Editor\template\esercizi\esami\14-07-08>javac CollezioneOggettiMisurabili.java
CollezioneOggettiMisurabili.java:86: incompatible types
found : java.lang.Object
required: Misurabile
return collezione.elementAt(i);
^
Note: CollezioneOggettiMisurabili.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.
1 error
A spanne direi che: return collezione.elementAt(i); è come se dovesse essere "castato" al tipo effettivo dell'oggetto che viene restituito e non ad un generico Object....questo a rigor di logica perchè credo che dipenda da questo il problema...
Allora guardando in giro ho capito che devo usare la reflection in qualche modo...tranne che non sò bene come fare, avevo iniziato a riscrivere il mio metodo get in questo modo:
public Misurabile get(int i){
// Metto nella variabile tipo il tipo effettivo degli oggetti contenuti nella collezione
Class tipo = collezione.elementAt(0).getClass();
if(i >= 0 && i <= collezione.size() && collezione != null) // Se possibile restituire l'elemento lo restituisce
return .....
else throw new FailureException(); // Se invece non lo è solleva una FailureException
}
In pratica voglio mettere dentro la variabile tipo il tipo effettivo degli oggetti contenuti nella mia collezione e poi vorrei ritornare un oggetto di quel tipo o qualcosa del genere...per favore mi aiutate a scrivere questo maledetto metodo get che mi sono bloccato....dai ragazzi...domani esame...se lo passo ve ne sarò eternamente grato e sopratutto non vi romperò per un bel po' con Java...
Tnx
vi prego di aiutarmi...domani esame....mi sono impicciato con questo esercizio d'esame dove c'è la reflection
Si consideri una collezione di oggetti generici e misurabili che sia omogenea (ovvero, tutti gli oggetti nella collezione sono dello stesso tipo), dinamica (ovvero, è possibile inserire e rimuovere oggetti dalla collezione) e dotata di un metodo in grado di accedere ai suoi elementi.
Si consideri un metodo cercaElemento che prende in input una tale collezione generica di oggetti C ed un oggetto obj, e cerca se nella collezione C è presente un oggetto la cui misura è uguale a quella di obj: in caso positivo il metodo restituisce l’indice di un oggetto la cui misura è uguale a quella di obj, altrimenti
a) se C contiene almeno un elemento la cui misura è minore a quella di obj, allora il metodo restituisce la lista degli elementi la cui misura è minore a quella di obj (in una forma ascelta), altrimenti
b) il metodo segnala che nessuna delle due eventualità precedenti è verificata.
Problema 1. Si richiede la progettazione del tipo di dati CollezioneOggettiMisurabili corrispondente alle specifiche sopra descritte e di tutti i tipi coinvolti, nonché la loro
implementazione in linguaggio Java. Per la classe CollezioneOggettiMisurabili si richiede la funzione di astrazione e l’invariante di rappresentazione.
Problema 2. Si richiede l’implementazione in linguaggio Java del metodo cercaElemento.
Io l'ho pensato così, ma mi impiccio in un punto e non sò che fare:
Per prima cosa definisco un'interface Misurabile che definisce dei generici oggetti misurabili che hanno in comune la capacità di misurarsi e di restituire tale valore.
public interface Misurabile{
/** OVERVIEW: Definisce oggetti misurabili ed implementa un metodo misura() */
double misura();
}
Poi definisco una classe chiamata CollezioneDiOggettiMisurabili che implementa la collezione in modo tale che contenga solo elementi aventi tutti lo stesso tipo effettivo e che implementa le 3 operazioni richieste: inserimento di un oggetto nella collezione (viene inserito se e solo se ha lo stesso tipo effettivo degli altri oggetti eventualmente presenti nella collezione), rimozione di un oggetto dalla collezione ed accesso ad un elemento della collezione.
Proprio l'implementazione dell'ultimo metodo mi stà creando non pochi problemi e credo che bisogna usare la reflection (che abbiamo trattato l'ultima lezione molto velocemente).
Questa è la mia classe, il metodo get() non riesco ad implementarlo del tutto:
import java.util.*;
import java.lang.*;
public class CollezioneOggettiMisurabili{
/** OVERVIEW: Rappresenta una collezione omogenea (tutti gli elementi appartenenti alla collezione devono avere lo stesso
tipo effettivo) di generici oggetti Misurabile
V = {{m_1, m_2, m_3,......., m_n} dove per ogni m_i è un oggetto misurabile}
O = 1) Inserisci() : Inserisce un oggetto nella collezione
2) Elimina(): Elimina un elemento dalla collezione
3) get(): Accede ad un determinato elemento della collezione
C = 0 (non ci sono costanti significative
F_a(): STATO CONCRETO -----> STATO ASTRATTO
F_a([3, 5, 8]) ------> {{3, 5, 8}, che sono oggetti InteriMisurabili}
I(oggetto): 1) oggetto.collezione != null (la collezione non deve mai essere null)
2) Per ogni i oggetto.get(i) è un Misurabile (tutti gli oggetti della collezione devono essere dei Misurabile)
3) Per ogni i oggetto.get(i) deve avere lo stesso tipo effettivo di tutti gli altri elementi della collezione
*/
private Vector collezione; // Per rappresentare la collezione di oggetti misurabili
/** COSTRUTTORE:
EFFECTS: Costruisce un nuovo oggetto di tipo CollezioneOggettiMisurabili che rappresenta la collezione vuota
@param: void
@return: Il riferimento ad un nuovo oggetto di tipo CollezioneOggettiMisurabili */
public CollezioneOggettiMisurabili(){
collezione = new Vector(); // Crea la collezione vuota
}
/** inserisci():
EFFECTS: Se possibile inserisce un nuovo oggetto all'interno della collezione. Se la collezione è vuota, l'oggetto
passatogli come parametro viene inserito nella prima posizione della collezione; Se invece la collezione
non è vuota, il parametro verrà inserito nella collezione se e solo se ha lo stessotipo effettivo degli
altri elementi appartenenti alla collezione
MODIFIES: this
@param: Il riferimento ad un oggetto di tipo Misurabile
@return: void */
public void inserisci(Misurabile m){
if(collezione.size() == 0) // Se la collezione è vuota
collezione.addElement(m); // Inserisce l'oggetto referenziato dal parametro in prima posizione
else{ // Se invece la collezione non è vuota
// Controlla che l'oggetto referenziato dal parametro abbia lo stesso tipo effettivo degli oggetti nella collezione
if(collezione.elementAt(0).getClass().isInstance(m)) // Se è vero
collezione.addElement(m); // Inserisce l'oggetto referenziato dal parametro in prima posizione
else throw new FailureException(); // Se invece non lo è solleva una FailureException
}
}
/** rimuovi():
EFFECTS: Se possibile rimuove l'i-esimo elemento dalla collezione, non è possibile rimuovere un elemento avente
posizione negativa o maggiore della dimensione della collezione
REQUIRES: La collezione non deve essere vuota ed il parametro che indica la posizione dell'elemento da rimuovere
deve essere >=0 e < della dimensione della collezione
@param: int indica la posizione dell'elemento da rimuovere
@return: void */
public void rimuovi(int i){
if(i >= 0 && i <= collezione.size() && collezione != null) // Se possibile rimuovi l'elemento lo rimuove
collezione.remove(i);
else throw new FailureException(); // Se invece non lo è solleva una FailureException
}
/** get():
EFFECTS: Se possibile restituisce l'i-esimo elemento dalla collezione, non è possibile restituire un elemento avente
posizione negativa o maggiore della dimensione della collezione
REQUIRES: La collezione non deve essere vuota ed il parametro che indica la posizione dell'elemento da restituire
deve essere >=0 e < della dimensione della collezione
@param: int indica la posizione dell'elemento da restituire
@return: Un oggetto di tipo Misurabile */
public Misurabile get(int i){
if(i >= 0 && i <= collezione.size() && collezione != null) // Se possibile restituire l'elemento lo restituisce
return collezione.elementAt(i);
else throw new FailureException(); // Se invece non lo è solleva una FailureException
}
}
Inizialmente il metodo get lo avevo implementato così ma poi compilando mi sono reso conto che è sicuramente sbagliato in quanto credo che il metodo elementAt restituisca un Object o comunque un generico Misurabile (confermate?) ed infatti il compilatore mi da questo errore:
C:\Programmi\Crimson Editor\template\esercizi\esami\14-07-08>javac CollezioneOggettiMisurabili.java
CollezioneOggettiMisurabili.java:86: incompatible types
found : java.lang.Object
required: Misurabile
return collezione.elementAt(i);
^
Note: CollezioneOggettiMisurabili.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.
1 error
A spanne direi che: return collezione.elementAt(i); è come se dovesse essere "castato" al tipo effettivo dell'oggetto che viene restituito e non ad un generico Object....questo a rigor di logica perchè credo che dipenda da questo il problema...
Allora guardando in giro ho capito che devo usare la reflection in qualche modo...tranne che non sò bene come fare, avevo iniziato a riscrivere il mio metodo get in questo modo:
public Misurabile get(int i){
// Metto nella variabile tipo il tipo effettivo degli oggetti contenuti nella collezione
Class tipo = collezione.elementAt(0).getClass();
if(i >= 0 && i <= collezione.size() && collezione != null) // Se possibile restituire l'elemento lo restituisce
return .....
else throw new FailureException(); // Se invece non lo è solleva una FailureException
}
In pratica voglio mettere dentro la variabile tipo il tipo effettivo degli oggetti contenuti nella mia collezione e poi vorrei ritornare un oggetto di quel tipo o qualcosa del genere...per favore mi aiutate a scrivere questo maledetto metodo get che mi sono bloccato....dai ragazzi...domani esame...se lo passo ve ne sarò eternamente grato e sopratutto non vi romperò per un bel po' con Java...
Tnx