Ciao,
tra qualche giono dovrò sostenere un secondo esame di Java...mi sono un po' bloccato con questo esercizio (che ho risolto in parte)...mi date una mano per favore?

Il testo dice:

Un insieme di processi condividono un unico buffer, di dimensioni illimitate, in cui possono scrivere e prelevare dati di tipo generico ma capaci di misurarsi.
Ciascun processo è caratterizzato dallo specifico tipo di dato che può scrivere e leggere dal buffer ed opera nella maniera seguente:

1) I processi possono iniziare ad operare solo dopo che il buffer è stato creato.

2) Un processo sa scrivere in fondo al buffer un dato del suo tipo, che riceve in input.

3) Un processo sa leggere dal buffer un dato del suo tipo: a questo scopo, tiene traccia della posizione p dell’ultimo dato del suo tipo letto dal buffer e, a partire dalla posizione p, cerca il successivo dato del suo tipo e lo restituisce in output.

4) Un processo sa cercare nel buffer un dato del suo tipo di misura minima; se tale dato esiste ed è unico
esso viene restituito in output, se esistono più dati del tipo corretto di valore minimo viene comunicato il numero di dati di valore minimo individuati, se il buffer non contiene alcun dato del tipo corretto viene comunicata la lista dei tipi dei dati contenuti nel buffer.

Si richiede l’implementazione in Java del tipo di dato Processo e degli altri eventuali tipi coinvolti.

Allora...io l'ho pensato così:

Inizialmente realizzo un'interface chiamata Misurabile che rappresenterà la caratteristica comune a tutti i tipi che la implementano e che potranno essere scritti nel buffer, ovvero la capacità di restituire la misura dell'oggetto:

codice:
/** 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
}
Poi implemento il tipo BufferDiMisurabili che mi rappresenta il mio buffer che viene condiviso dai vari processi:

codice:
/** OVERVIEW: La classe rappresena un buffer, di dimensioni illimitate, in cui un insieme di processi possono scrivere o
			  leggere un dato di tipo Misurabile */
			  
private class BufferDiMisurabili{
	
	private Vector BufferMisurabili;	// Il buffer di dimensioni illimitate viene rappresentato da un Vector
	
	/* Rappresenta lo stato del buffer: true se il buffer è stato creato, false altrimenti. Inizialmente è settato a false */
	private boolean statoBuffer = false; 
	
	/** EFFETCTS: Crea un nuovo buffer di oggetti misurabili e setta a true lo stato del buffer
		@param: void
		@return: Il riferimento ad un oggetto di tipo BufferDiMisurabili */
		
	public BufferDiMisurabili(){
		V = new Vector();				// Crea un buffer vuoto
		statoBuffer = true;	// Setta a true statoBuffer così da identificare che il buffer è stato creato ed è pronto all'uso
	}
	
	/** EFFECTS: Inserisce un generico oggetto di tipo Misurabile dentro il buffer se questo è stato creato, altrimenti
				 solleva una failureException 
		@param: Il riferimento ad un oggetto Misurabile
		@return: void */
		
	public set(Misurabile m){
		if(statoBuffer == true)					// Se il buffer è stato creato
			V.addElement(m);					// Aggiunge il parametro al buffer
		else throw new FailureException();		// Altrimenti solleva un'eccezione
	}
	................
	................
	.................
	
}
A questo punto iniziano i problemi ed i dubbi su come fare quello che devo fare:

1) Per quanto riguarda l'inserimento in fondo al buffer di un generale dato Misurabile non credo ci siano problemi, invece per quanto riguarda la lettura? dentro la classe che rappresenta il buffer cosa ci devo mettere?

2) Come implemento la classe processo? Possono essere tanti tipo di processi...processi che leggono e scrivono interi,processi che leggono e scrivono stringhe e così via? Devo usare una classe abstract che ne rappresenta la struttura comune e poi estenderla ed ognuna di esse userà un proprio ditpo di oggetto Misurabile? Ad esempio ho un processo lettore e scrittore di interi che userà al proprio interno un InteroMisurabile che implemente Misurabile

Qualche consiglio?

Tnx