Ciao,
a breve avrò l'esame di linguaggi di programmazione che contiene una parte in Java, vi posto i primi due punti del testo della parte relativa a Java:

"Un insieme di processi condividono un unico buffer in cui possono scrivere e prelevare dati di tipo intero. Il
buffer ha dimensioni limitate, fissate al momento della sua creazione, ed i processi sono sottoposti ai vincoli
seguenti:
1) I processi possono iniziare ad operare solo dopo che il buffer è stato creato
2) Un processo può essere di tipo scrittore (ed in questo caso potrà solo scrivere dati nel buffer) oppure
lettore (ed in questo caso potrà solo leggere dati dal buffer cancellandoli nel contempo)
3) Un processo può scrivere un valore intero dal buffer solo se il buffer non è pieno
4) Un processo può leggere o rimuovere un dato dal buffer solo se il buffer non è vuoto.
Ciascun processo è caratterizzato dal suo tipo (scrittore o lettore) e:
a) Se il processo è di tipo scrittore, allora esso contiene tutti i valori che (eventualmente)
scriverà sul buffer
b) Se il processo è di tipo lettore, allora esso contiene un’area di memoria in cui scrivere i
valori che (eventualmente) preleverà dal buffer.
Problema 1. Si richiede il progetto di un tipo astratto di dato Processo che rappresenti processi del tipo
appena descritto. Le operazioni di interesse per il tipo di dati sono quelle evidenziate nei punti sopra.
Si osserva esplicitamente che, in accordo con i principi di programmazione orientata agli oggetti sui quali è
basato il corso, un tipo di dati deve occuparsi della consistenza e correttezza dei dati che rappresenta rispetto
a tutti gli aspetti considerati. Pertanto il tipo di dati Processo deve opportunamente occuparsi anche della
gestione del buffer.
Problema 2. Si richiede l’implementazione in Java del tipo astratto di dato Processo ."

Vabbè vi risparmio il tipo di dati astratto che sono quasi certo che vada bene e vi posto direttamente la mia soluzione in Java, commentata...mi dite se va bene?

codice:
public class Processo{
	
	private static int [] buffer = new int[30];	// Creo una variabile di classe di tipo array di int e alloco un array di 30 elementi
	private static int dove;
	
	private boolean scrittore;	// Se scrittore è true allora il processo è di tipo scrittore, se è false è di tipo lettore
	private int [] area;		// E' l'area di memoria interna ad ogni processo
	private int quale;			// Posizione dell'elemento da scrivere o leggere presente nell'area di memoria dei processi
	
	/** Costruttore 1: CREA UN PROCESSO DI TIPO LETTORE quindi dovrà creare un'area di memoria vuota per tale processo
		@param dim di tipo int: è la dimensione dell'area di memoria interna al processo
		@return un oggetto di tipo Processo lettore */
		
	public Processo(int dim){
		
		if(dim > 0){				// Se il valore della dimensione dell'area di memoria ricevuto è coerente
			area = new int[dim];	// allora crea un array di interi di dimensione dim e metti in area il suo riferimento
			quale = -1;				//
			scrittore = false;		// L'oggetto di tipo Processo viene creato come processo lettore
		}
		
		else{						// Se invece il valore della dimensione dell'area di memoria ricevuto non è coerente
			System.err.println("Errore: valore della dimensione dell'area di memoria non coerente");	// Messaggio d'erore
			area = null;
			quale = null;	// Imposta le variabili di istanza a null
		}
	}
	
	/** Costruttore 2: CREA UN PROCESSO DI TIPO SCRITTORE: l'area di memoria del processo scrittore è già esistente e vi
		copiato il contenuto del parametro: un'array, che poi sarà copiato nel buffer
		@param mem di tipo int []: è l'array di interi che deve essere copiato nell'area di memoria del processo
		@return un oggetto di tipo Processo scrittore */
		
	public Processo(int [] mem){
		
		int i;							// Variabile contatore
		scrittore  = true;				// L'oggetto di tipo Processo viene creato come processo scrittore
		quale = 0;						//
		area = new int [mem.length];	// L'array area viene creato avente la stessa dimensione dell'array parametro
		
		for(i = 0; i < area.length; i++)
			area[i] = mem[i];			// Copia tutti gli elementi dell'array ricevuto nell'area di memoria del processo
			
	}
	
	/** Legge i valori dal buffer e li copia nell'area di memoria dell'oggett Processo che riceve il messaggio
		@param void
		@return void */
	
	public void leggi(){
		
		/* Se il processo è di tipo lettore e se l'indice del prossimo elemento dell'area di memoria del processo è minore
		   della dimensione dell'array che la implementa e se il buffer non è vuoto */
		if(!scrittore ^ quale+1<area.length ^ dove>-1){
			area[quale] = buffer[dove];						// Copia un elemento dal buffer all'area di memoria
			quale++;										// Incrementa l'indice nell'area di memoria
			dove--;											// Decrementa l'indice del buffer e svuota la locazione
		}
		
		else
			System.err.println("Errore");					// Altrimenti stampa un messaggio di errore
		
	}
	
	/** Scrivi i valori presenti nell'area di memoria del processo ricevente nel buffer
		@param void
		@return void */
	
	public void scrivi(){
		
		/* Se il processo è di tipo scrittore e se l'indice  del prossimo elemento dell'area di memoria è minore dela
		   dimensione dell'array che la implementa e se l'indice della prossima posizione del buffer è minore della sua
		   dimensione */
		if(scrittore ^ quale < area.length ^ dove+1 < buffer.length){
			buffer[dove+1] = area[quale];		// Copia l'elemento corrente dell'area di memoria nel buffer
			quale ++;						// Incrementa alla prossima locazione di memoria del processo che sarà copiata
			dove ++;						// Incrementa alla prossima locazione del buffer dove copiare il prossimo elemento
		}
		
		else
			System.err.println("Errore");					// Altrimenti stampa un messaggio di errore
		
	}
	
}
Mi dà un errore quando faccio: quale = null;
credo che dipenda dal fatto che quale è di tipo int e il null lo posso assegnare solo a valori di tipo riferimento? eventualmente come risolvere per attribuire un valore nullo ad un intero? gli dò -1 come valore di errore?
Come logica ci può stare queta soluzione?

Grazie
Andrea