[JAVA] Supertipi e sottotipi, posso fare questa cosa?

[Rintrah84]

Ciao,
allora la situazione è questa, ho un'interface che mi definisce dati di tipo Misurabile che come unica caratteristica comune hanno la capacità di restituire la loro misura:

/** OVERVIEW: Si tratta di un'interface che descrive la caratteristica comune ad una serie di tipi che la implementeranno:
			  ovvero la capacità di restituire al chiamante la propria misura */
			  
public interface Misurabile{
	double misura();			// Ogni elemento di tipo Misurabile deve essere capace di misurarsi
}

Da tale interfece implementerò poi varie classi come InteroMisurabile, RettangoloMisurabile, FrazioneMisurabile, etcetc.

Poi ho una classe chiamata Processo che contiene un metodo inserisci che inserisce un QUALSIASI oggetto Misurabile dentro un buffer rappresentato da un Vector:

public class Processo{
	
	/* Il buffer condiviso dai vari processi viene rappresnentato mediante un Vector definito come variabile di classe */
	
        private static Vector buffer;
	static boolean statoBuffer = false;	/* TRUE: il buffer è stato creato; FALSE: il buffer non è stato creato

	/** EFFECTS: Si tratta di un metodo di classe che crea il buffer (rendendo possibile le operazioni dei processi su di
				 esso) e setta a TRUE la variabile statoBuffer. Tale metodo è comune a tutti i tipi di processi e viene
				 implementato nella classe abstract */
				 
	public static void creaBuffer(){
		
		if(statoBuffer = false){			// Se il buffer non è stato ancora creato
			buffer = new Vector();			// Crea il nuovo buffer
			statoBuffer = true;	 // Setta a true statoBuffer per avvertire i processi che il buffer è creato e pronto all'uso
		}

	/** EFFETCT: Inserisce un qualsiasi oggetto di tipo Misurabile nel buffer se il buffer è stato correttamente creato,
				 altrimenti solleva un'eccezione
		@param: il riferimento ad un oggetto Misurabile */
		
	public void inserisci(Misurabile m){
		
		if(statoBuffer = false) throw new FailureException();		// Se il buffer non è stato creato solleva un'eccezione
		else buffer.addElement(m);				// Altrimenti aggiungi l'oggetto referenziato da m alla fine del buffer
	}
		
}

Così facendo al metodo inserisci() gli passo il riferimento ad un qualsiasi oggetto che ha supertipo Misurabile e voglio che lo inserisca a prescindere di quale sia il suo tipo effettivo (mi basta che sia un Misurabile per essere inserito nel buffer).

Si può fare?

Grazie

[banryu79]

Originariamente inviato da Rintrah84

Così facendo al metodo inserisci() gli passo il riferimento ad un qualsiasi oggetto che ha supertipo Misurabile e voglio che lo inserisca a prescindere di quale sia il suo tipo effettivo (mi basta che sia un Misurabile per essere inserito nel buffer).

Si può fare?

Grazie

Se l'interfaccia Misurabile è stata implementata da ogni classe di oggetti che vai ad inserire nel tuo buffer, ovviamente sì.

[Rintrah84]

Originariamente inviato da banryu79

Se l'interfaccia Misurabile è stata implementata da ogni classe di oggetti che vai ad inserire nel tuo buffer, ovviamente sì.

Ok, ti ringrazio, intendi dire se ho implementato tutti i sottotipi che prevedo possano essere usati per popolare in mio buffer?

Tnx

[banryu79]

Originariamente inviato da Rintrah84

Ok, ti ringrazio, intendi dire se ho implementato tutti i sottotipi che prevedo possano essere usati per popolare in mio buffer?
Tnx

Sì, ovvero finchè nel buffer ci infili oggetti il cui tipo implementa l'interfaccia Misurabile, quando poi andrai a invocare il metodo misura() su un oggetto a caso del buffer stesso avrai la garanzia che tutto funge; in caso contrario a runtime partirebbe una ClassCastException.

Per fare le cose in maniera un po' più type safe, potresti fare uso dei Generics; in particolare rendere il tuo buffer generalizzabile facendo in modo che il client debba specificare il tipo di elementi inseribili nel buffer.

Esempio: supponiamo che buffer sia una lista implementa dalla classe ArrayList.
Usiamo i Generics per specificare che gli elementi inseribili sono solo quelli che implementano l'interfaccia Misurabile:

// dichiarazione
List<Misurabile> buffer; 

// inizializzazione
buffer = new ArrayList<Misurabile>();

Ora se in buffer provi a cacciarci oggetti non Misurabili, che so, una java.lang.String per esempio, il compilatore si lamenta.

Quindi hai una maggiore type safety perchè il problema si manifesta già a compile-time, mentre prima accadeva solo a run-time.