[java] esercizio su generics e wildcards, pareri su come l'ho svolto...

[marius84]

ciao a tutti, ho questo esercizio:

[Dipendenze] Si vuole definire una classe per gestire insiemi di oggetti che hanno relazioni di dipendenza tra loro. Gli oggetti potrebbero rappresentare persone (ad esempio, impiegati di una azienda con le relazioni di dipendenza basate sui loro ruoli) oppure cose o entità astratte (files di configurazione il cui aggiornamento dipende da altri file di configurazione, classi in un programma che dipendono da altre classi, compiti o processi la cui esecuzione dipende dall'esecuzione di altri compiti, ecc.). Per garantire la massima generalità si conviene che affinchè un tipo possa considerarsi coinvolto in una relazione di dipendenza è sufficiente che il tipo stesso o un suo supertipo T implementi la seguente interfaccia generica:

public interface Dependent<T> {
// ritorna true se questo oggetto è direttamente dipendente da x o se è uguale a x
boolean isDependentOn(T x);
}

Il metodo dell'interfaccia determina solamente la dipendenza diretta e quindi, in generale, non è transitiva. Invece, una relazione di dipendenza è è per sua natura transitiva, cioè, se x dipende da y e y dipende da z, allora x dipende anche da z. L'esercizio chiede di definire una classe per gestire insiemi di oggetti coinvolti in una relazione di dipendenza (tramite l'interfaccia Dependent<T>) che permette di ottenere informazioni sulle dipendenze tra gli oggetti dell'insieme che sono conseguenza della transitività. La classe ha un costruttore che crea un insieme vuoto (potrebbe anche essere quello di default). Poi, deve avere metodi per le seguenti operazioni:

* aggiunta di un oggetto all'insieme;
* rimozione di un oggetto dall'insieme;
* controllo se un oggetto appartiene all'insieme;
* creazione e ritorno di un insieme contenente tutti gli elementi dell'insieme che sono direttamente dipendenti da un dato oggetto;
* creazione e ritorno di un insieme che contiene tutti gli elementi dell'insieme che sono direttamente dipendenti da al meno uno degli elementi di un dato insieme;
* creazione e ritorno di un insieme che contiene tutti gli elementi dell'insieme che sono transitivamente dipendenti da un dato oggetto.

Chiaramente gli oggetti e gli oggetti degli insiemi dei parametri di input dei metodi devono essere del tipo giusto. La classe deve anche implementare l'interfaccia Iterable.


e l'ho svolto in questo modo, vorrei sapere se secondo voi è giusto, ed ho usato nel modo corretto i tipi generici con le relative wildcards...

grazie a tutti

//qls tipo che implementa l'interfaccia Dependent,
//accetta anche tipi T che hanno come super tipo ? che implementa Dependent

public class RelDipendenza<T extends Dependent<? super T> implements Iterable<T> {

	
	private  Set<T> insieme;
	
	//costruttore
	public RelDipendenza(){
		insieme=new HashSet<T>();
	}
	
	public void add(T x){
		insieme.add(x);
	}
	
	public void remove(T x){
		insieme.remove(x);
	}
	
	public boolean contains(T x){
		return insieme.contains(x);
	}
	
	
	//* creazione e ritorno di un insieme contenente tutti gli elementi dell'insieme che sono direttamente dipendenti da un dato oggetto;	
	public Set<T> dirDip(T x){
		
		Set<T> dipendenzeDir=new HashSet<T>();
		
		for(T y:insieme)
			if(y.isDependentOn(x)) 
				dipendenze.add(y);
		
		return dipendenze;
	}
	
	// * creazione e ritorno di un insieme che contiene tutti gli elementi dell'insieme che sono direttamente dipendenti da al meno uno degli elementi di un dato insieme;
	
	public Set<T> DipDir(Set<T> ins){
		
		Set<T> dipendenzeDir=new  HashSet<T>();
		
		for(T y: insieme)
			for(T x : ins)
				if(y.isDependentOn(x))
					dipendenze2.add(y);
		
		return dipendenzeDir;
	}
	
	// * creazione e ritorno di un insieme che contiene tutti gli elementi dell'insieme che sono transitivamente dipendenti da un dato oggetto. 
	
	public Set<T> DipTransit(T x){
		
		Set<T> dipendenzeTransit=new HashSet<T>();
		Set<T> tmp=new HashSet<T>();
		
		
		//salvo tutti gli oggetti dell'insieme che hanno dipendenza diretta con  x
		for(T y: insieme)
			if(y.isDependentOn(x))
				tmp.add(y); 
		
		//salvo  tutti gli oggetti dell'insieme che hanno dipendenza diretta con quelli  dell'insieme tmp;
		for(T z: insieme)
			for(T y: tmp)
				if(z.isDependentOn(y))	
					dipendenzeTrasit.add(z);
	
		return dipendenzeTransit;
	}
		
		
	public 	Iterator<T> iterator(){
		return insieme.iterator();
	}
					
}

[marius84]

qualche consiglio ?