[Java] Esercizio d'esame, va bene secondo voi?

[D4rkAng3l]

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?

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

[agente mm8]

Un riassuntino? Non credo che qualcuno in questo forum non abbia così niente da fare da mettersi a leggere stò romanzo...

[D4rkAng3l]

Originariamente inviato da agente mm8

Un riassuntino? Non credo che qualcuno in questo forum non abbia così niente da fare da mettersi a leggere stò romanzo...

Beh in effetti è vero anche se credo sia più corto di quanto scritto perchè del punto 1 non ho postato la soluzione in quanto ce l'ho corretta su carta e non mi interessa.

In pratica devo implementare in Java una classe che mi rappresenta il tipo di dato Processo

Tutti i processi condividono un buffer realizzato mediante una variabile di classe array di interi. Gli oggetti di tipo Processo al loro interno devono avere un'area di memoria (rappresentata sempre con un array di interi, questa volta però si tratta di una variabile di istanza perchè è relativa ad ogni singolo oggetto Processo creato)

I processi possono essere di due tipi: lettore o scrittore, se un processo viene creato come lettore potrà solo copiare nella sua memoria interna il contenuto del buffer.
Se invece è creato come scrittore devo passare al costruttore un array di interi che contiene gli elementi da copiare prima nella sua memoria interna e poi nel buffer condiviso da tutti i processi.

Tnx
Andrea

[Oceans11]

Originariamente inviato da D4rkAng3l

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?

Beh o gli dai un valore che sai essere senza significato in questo particolare programma, oppure utilizzi un wrapper per contenere l'informazione. Per esempio se usi Integer puoi anche impostarlo a null essendo un Integer oggetto

[Don[ITA]]

Mmmm....secondo me non è molto corretto il modo in cui hai svolto l'esercizio...
Io leggendo il testo capisco che:
-devo creare una classe Processo astratta che contenga un riferimento a Buffer e qualcosa che mi rappresenta l'area di memoria dove salvare i valori letti o scritti
-devo creare una classe Lettore che estende Processo e implementa i metodi di lettura dal buffer con i relativi controlli specificati
-devo creare una classe Scrittore che estende Processo e implementa i metodi di scrittura nel buffer con i relativi controlli specificati
-devo creare una classe Buffer che abbia al suo interni un array di int che lo rappresenta e i relativi metodi sincronizzati per l'accesso a tale array
Ovviamente così è come lo interpreto io non è detto che abbia ragione

Saluti

[D4rkAng3l]

Originariamente inviato da Don[ITA]

Mmmm....secondo me non è molto corretto il modo in cui hai svolto l'esercizio...
Io leggendo il testo capisco che:
-devo creare una classe Processo astratta che contenga un riferimento a Buffer e qualcosa che mi rappresenta l'area di memoria dove salvare i valori letti o scritti
-devo creare una classe Lettore che estende Processo e implementa i metodi di lettura dal buffer con i relativi controlli specificati
-devo creare una classe Scrittore che estende Processo e implementa i metodi di scrittura nel buffer con i relativi controlli specificati
-devo creare una classe Buffer che abbia al suo interni un array di int che lo rappresenta e i relativi metodi sincronizzati per l'accesso a tale array
Ovviamente così è come lo interpreto io non è detto che abbia ragione

Saluti

No...è il primo corso di programmazione orientata agli oggetti ed è la prima volta che usiamo Java...prendilo come un esempio per creare un tipo di dato, per esempio argomenti come le classi astratte e l'ereditarietà non sono trattati in questo corso ma saranno trattati nel secondo modulo al prossimo semestre...