[JAVA] Uso interface, ho fatto giusto? Qualche dubio...

[D4rkAng3l]

Ciao,
tra pochissimi giorni avrò un esame universitario di Java...vi propongo un esercizio di un vecchio appello e la mia soluzione, mi potreste dire se ho fatto giusto? Sembra lungo ma in realtà il dubbio ce l'ho solo sull'implementazione di una classe, il resto del codice lo posto solo per completezza.

Questo è il testo d'esame:

Siano date le due classi CollezioneDiStringhe e CollezioneDiInteger, le cui specifiche sono
illustrate nel seguito:

1) CollezioneDiStringhe rappresenta e gestisce collezioni statiche di oggetti di tipo String non
contenenti duplicati. La sua interfaccia è la seguente:

CollezioneDiStringhe(String[] S): il costruttore che crea un oggetto istanza di CollezioneDiStringhe il cui stato corrisponde ad S privato degli eventuali duplicati;

int size(): restituisce il numero di elementi della collezione;

String get(int i): se il parametro i ha un valore valido restituisce la i–esima stringa della collezione, altrimenti restituisce null.

2) CollezioneDiInteger rappresenta e gestisce collezioni dinamiche di oggetti di tipo Integer. La
sua interfaccia è la seguente:

CollezioneDiInteger(): il costruttore che crea un oggetto istanza di CollezioneDiInteger il cui stato corrisponde alla collezione vuota;

void add(int n): aggiunge il parametro alla collezione;

Integer get(int i) throws IndiceErratoException: se il parametro i ha un valore valido restituisce l’i–esimo elemento della collezione, altrimenti solleva una eccezione checked di tipo IndiceErratoException.

Problema 1. Si consideri un metodo di tipo boolean cercaElemento che prende in ingresso due parametri,
C e og: il tipo del primo parametro C è una collezione generica di oggetti, mentre il secondo parametro og è
un oggetto generico. Il metodo cercaElemento estrae da C un iteratore e, utilizzando tale iteratore, verifica se
og è contenuto in C. Si richiede il progetto e l’implementazione in linguaggio Java di cercaElemento e di
tutti gli eventuali tipi di dato coinvolti.

Problema 2. Si richiede il progetto e l’implementazione in linguaggio Java di due tipi di dato corrispondenti
a CollezioneDiStringhe e CollezioneDiInteger in modo tale che essi possano essere parametri del
metodo cercaElemento.

MIA SOLUZIONE:

Vabbè per risolvere il primo punto semplicemente creo una classe Test dove ci caccio dentro il metodo static cercaElemento. A tale metodo faccio prendere in input un parametro di tipo CollConIteratore (che rappresenta una generica collezione dotata di iteratore) ed un object.

Allora definisco un'interface CollConIteratore che appunto mi definisce le caratteristiche di una generica colezione dotata di iteratore e tale caratteristica è proprio l'avere disponibile un iteratore.

Infine prendo le due classi che mi dà lui, le incarto in altre due classi che chiamo CollStrConIteratore e CollIntConIteratore che estendono rispettivamente le relative due classi fornitemi e che implementano entrambe la mia interface CollConIteratore.

Vi posto i codici delle varie classi tanto per maggior chiarezza ma il vero dubbio lo ho sulla classe CollIntConIteratore

classe Test:

public class Test{
	
	/** EFFECTS: Verifica se il parametro og è contenuto nella collezione referenziata dal paramentro c
		@param: c di tipo CollConIteratore
		@param obg ti tipo Object
		@return: un valore booleano */
	
	static boolean cercaElemento(CollConIteratore c, Object obg){
		
		boolean ris = false;
		Iterator it = c.enumera();			// Estrae un iteratore da c
		
		/* Finchè nella collezione ci sono ancora elementi su cui iterare e finchè non è stato trovato un elemento nella
		   collezione */
		while(it.hasNext() && !ris){
			if(obj.equals(it.next())	// Se il parametro obj equivale all'elemento corrente su cui si sta iterando
					ris = true;			// setta ris a true
			
			it.remove;	// Elimina l'elemento corrente dall'iteratore (non dalla collezione) e passa al prossimo elemento
		}
		
		return ris;		// Ritorna ris al chiamante;
	}
}

Interface CollConIteratore:

public interface CollConIteratore{
	public Iterator enumera();
}

Classe CollStrConIteratore:

public class CollStrConIteratore extends CollezioneDiStringhe implements CollConIteratore{ // Ereditarietà multipla
	
	/** EFFECTS: Costruisce un oggetto di tipo CollStrConIteratore eliminando i duplicati dall'array parametro
		@param: Un'array di stringhe
		@return: Il riferimento ad un nuovo oggetto di tipo CollStrConIteratore */
	
	public CollStrConIteratore(String[] x){
		super(x);		// Invoca il costruttore della superclasse CollezioneDiStringhe passandogli l'array di stringhe x
	}
	
	public Iterator enumera(){			// Metodo enumera 
		return new MioIteratore();		// che restituisce un oggetto di tipo MioIteratore definito nella classe interna
	} 
	
	/* Nella classe interna MioIteratore implemento i metodi dell'interface Iterator */
	private class MioIteratore implements Iterator{	
		
		int i;
		
		public MioIteratore(){			// COSTRUTTORE DEL GENERATORE
			i = 0;						// Quando viene costruito parte ad iterare dal primo elemento della collezione
		}
		
		public Object next(){			// Restituisce l'i-esimo elemento della collezione
			return get(i);
		}
		
		public boolean hasNext(){		// Dice se c'è un altro elemento nella collezione
			return i<size();
		}
		
		public void remove(){	 // Rimuove l'elemento dall'iteratore (non dalla collezione) passando al prossimo elemento
			i++;
		}
	}
}

Classe CollIntConIteratore:

public class CollIntConIteratore extends CollezioneDiInteger implements CollConIteratore{	// Ereditarietà multipla

	/* NELLA SOTTOCLASSE CollIntConIteratore NON C'E' BISOGNO DI IMPLEMENTARE IL COSTRUTTORE IN QUANTO NELLA CLASSE PADRE
	   CollezioneDiInteger IL COSTRUTTORE E' SENZA PARAMETRO */
	   
	public Iterator enumera(){			// Metodo enumera 
		return new MioIteratore();		// che restituisce un oggetto di tipo MioIteratore definito nella classe interna
	} 
	
	/* Nella classe interna MioIteratore implemento i metodi dell'interface Iterator */
	private class MioIteratore implements Iterator{
		
		public MioIteratore(){			// COSTRUTTORE DEL GENERATORE
			i = 0;						// Quando viene costruito parte ad iterare dal primo elemento della collezione
		}
		
		public Object next(){			// Restituisce l'i-esimo elemento della collezione
			Object ris;
			
			try{						// Prova ad eseguire l'operazione
				ris = get(i);			// Metti in ris il riferimento all'i-esimo oggetto della collezione
			}catch(IndiceErratoException e){  // Se viene sollevata una IndiceErratoException (quando ho iterato su tutti gli elementi
				throw IndiceErratoException	  // Rilancia al chiamante l'eccezione così si accorge che non ci sono più elementi su cui iterare
				}
			
			return ris;
		}
	
		public boolean hasNext(){				// Dice se c'è un altro elemento nella collezione
			boolean EsistProssimo = true;					// Setto a true la variabile booleana EsisteProssimo
		
			try{			// Prova ad eseguire il metodo get() sull'(i+1)-esimo elemento della collezione
				get(i+1);
			}catch(IndifceErratException e){	// Se viene sollevata l'eccezione significa che l'i-esimo elemento era l'ultimo
				ris = false;					// allora gestisce l'eccezione settando EisteProssimo a false
			}
		
			return EsisteProssimo;
		}
	
		public void remove(){	 // Rimuove l'elemento dall'iteratore (non dalla collezione) passando al prossimo elemento
			i++;
		}
	}
	
}

Ah vabbè mi sono appena accorto che in teoria nelle classi dovrei importare l'iteratore fornito dalla JDK ma vabbè quella è una riga per ogni classe...

Cmq il dubbio è sulla mia implementazione di CollIntConIteratore sopratutto per quanto riguarda il metodo next che voglio che fornisca l'elemento corrente della collezione (l'elemento che non è stato ancora eliminato dall'iteratore con delete).
Posso farlo quel giochetto dell'ecezione che ho fatto? cioè che se next prova ad accedere ad un elemento non valido gli arriva l'eccezione e lui gestendola la rilancia al chiamante che viene così avvertito che l'elemento non è valido?

Discorso simile per il metodo hasNext dove se provo ad accedere al successivo elemento e ricevo un'eccezione allora la gestisco settando a false la variabile...si può fare?

Please help me

Grazie
Andrea

[D4rkAng3l]

up