[JAVA] Problema con reflection, urgente :-(

[e-commerce84]

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

[PGI-Bis]

Confesso candidamente di essermi perso per strada verso i due quinti del post. Provo con una "dritta", buttata un po' lì a tentoni.

Se è vero che Vector piglia e restituisce Object è vero anche che CollezioneDiOggettiMisurabili non è costretta a prendere e dare Object: può benissimo ricevere e restituire dei Misurabile.

Cioè se questo è l'unico punto in cui qualcosa è inserito in collezione:

public void inserisci(Misurabile m) {
    collezione.add(m);
}

necessariamente vale la condizione "gli elementi di collezione sono di tipo Misurabile". E se vale questa condizione allora vale anche:

public Misurabile get(int index) {
    Object value = collezione.get(index);
    Misurabile m = (Misurabile)value;
    return m;
}

Verso l'esterno il contratto di una classe in cui esiste il solo metodo inserici per aggiungere elementi a collezione esiste un invariante di rappresentazione degli elementi di collezione stessa (Misurabile). La presenza di questo "fatto necessariamente vero" rende necessariamente valida la conversione esplicita Misurabile x = (Misurabile)collezione.get(qualcosa). Vector.get restituisce un Object ma se io so che in quel vector ci metto solo dei Misurabile allora non può non valere la conseguenza che tutto ciò che tiro fuori da quel vector sia un Misurabile.

Spero che questo possa esserti utile. A prescindere da questo la riflessione non mi sembra entrare in gioco (se non limitatamente ad una verifica del tipo di "value" da farsi con instanceof ma, ripeto, che sia un Misurabile appare scontato).