1 Astrazione sul controllo: gli iteratori. 2 Perché vogliamo iterarare “in modo astratto” 4 problema: iterare su tipi di dato arbitrari  esempio: procedura.

Presentazione sul tema: "1 Astrazione sul controllo: gli iteratori. 2 Perché vogliamo iterarare “in modo astratto” 4 problema: iterare su tipi di dato arbitrari  esempio: procedura."— Transcript della presentazione:

1 1 Astrazione sul controllo: gli iteratori

2 2 Perché vogliamo iterarare “in modo astratto” 4 problema: iterare su tipi di dato arbitrari  esempio: procedura stand-alone per calcolare la somma di tutti gli elementi di un IntSet public static int setSum (IntSet s) throws NullPointerException // EFFECTS: se s è null solleva // NullPointerException altrimenti // ritorna la somma degli elementi di s

3 3 Problema 4 Non vediamo la rappresentazione (p.e. quella realizzata dal vettore els) 4 Dobbiamo usare i metodi pubblici forniti dalla classe IntSet 4 Unico modo per accedere agli elementi: choose

4 4 L’insieme di interi 1 public class IntSet { // costruttore public IntSet () // EFFECTS: inizializza this a vuoto // metodi public void insert (int x) // MODIFIES: this // EFFECTS: aggiunge x a this public void remove (int x) // MODIFIES: this // EFFECTS: toglie x da this public boolean isIn (int x) //EFFECTS: se x appartiene a this ritorna // true, altrimenti false...}

5 5 L’insieme di interi 2 public class IntSet {... // metodi... public int size () // EFFECTS: ritorna la cardinalità di this public int choose () throws EmptyException // EFFECTS: se this è vuoto, solleva // EmptyException, altrimenti ritorna un // elemento qualunque contenuto in this }

6 6 Una soluzione 4 Prendiamo un elemento a caso con il metodo choose 4 Lo rimuoviamo 4 Ripetiamo fino a svuotare l’insieme 4 La procedura non deve modificare l’insieme (non e’ riportato in MODIFIES) 4 Quindi ci vuole una struttura di supporto per memorizzare gli elementi

7 7 Soluzione insoddisfacente 1 public static int setSum (IntSet s) throws NullPointerException { // EFFECTS: se s è null solleva // NullPointerException altrimenti // ritorna la somma degli elementi di s int[ ] a = new int [s.size( )]; int sum = 0; for (int i = 0; i < a.length; i++) {a[i] = s.choose( ); sum = sum + a[i]; s.remove(a[i]); } // risistema s for (int i = 0; i < a.length; i++) s.insert(a[i]); return sum;}  ad ogni iterazione vengono chiamate due operazioni ( choose e remove ) 4 gli elementi rimossi li mettiamo in un array, poi li riinseriamo

8 8 Soluzione Sbagliata 4 Un modo di risolvere il problema (accedere alla rappresentazione) 4 Per esempio, in IntSet accedere agli elementi memorizzati nel vettore els (dichiarando il vettore pubblico) 4 Da evitare: rompe l’astrazione rendendo dipendenti gli altri moduli dall’implementazione

9 9 Soluzione insoddisfacente 2 4 Il tipo di dato astratto non e’ progettato bene (metodi pubblici forniti sono limitati….)  potremmo aggiungere setSum come metodo d’istanza della classe IntSet –in modo più efficiente accedendo la rappresentazione –non è direttamente collegata al concetto di IntSet –quante altre operazioni simili dovremmo mettere in IntSet ? trovare il massimo elemento..... 4 Meglio sarebbe modifacre la specifica mettendo delle operazioni che siano un piu’ generali

10 10 Cosa non fare  dotiamo IntSet di una operazione che ritorna la rappresentazione (metodo d’istanza) public Vector members () // EFFECTS: restituisce il Vector contenente gli // elementi di this 4 Un metodo di questo tipo rende accessibile la rappresentazione (rompe l’astrazione) 4 Il codice della procedura dipende dalla rappresentazione 4 Non possiamo piu’ garantire le proprieta’ di IntSet ( il vettore puo’ essere modificato dall’esterno)

11 11 Soluzione leggermente diversa public int [ ] members () // EFFECTS: restituisce un array contenente gli // elementi di this, ciascuno esattamente una volta, // in un ordine arbitrario public static int setSum (IntSet s) { int[ ] a = s.members(); int sum = 0; for (int i = 0; i < a.length; i++) sum = sum + a[i]; return sum;} 4 inefficiente –due strutture dati –non sempre vogliamo generare tutti gli elementi della collezione massimo elemento

12 12 Di cosa abbiamo bisogno? 4 un meccanismo generale di iterazione, che permette di iterare sugli elementi di IntSet –facile da usare –efficiente –che preservi l’astrazione (ovvero che non riveli a chi lo usa il modo in cui l’insieme e’ implementato)

13 13 Vorremmo un generatore 4 un generatore g produce in modo incrementale (uno alla volta) tutti gli elementi i della collezione corrispondente all’oggetto 4 Utilizzando un generatore e’ possibile realizzare l’iterazione astratta: per ogni i prodotto da g esegui a su i 4 l’azione a da compiere sugli elementi è separata dalla generazione degli elementi stessi

14 14 Generatori in Java 4 i generatori sono oggetti di particolari classi (tipi)  Sono sottotipi di una Interfaccia Iterator –il tipo Iterator è definito dalla seguente interfaccia Java ( java.util package )

15 15 Cos’e’ una Interfaccia 4 Una Interfaccia e’ un particolare tipo di classe 4 Contiene solo specifica e nessuna implementazione 4 La specifica non contiene costruttori e neanche metodi statici 4 Solo metodi d’istanza

16 16 Sottotipi di una interfaccia 4 Si definiscono usando la parola chiave implements (al posto di extends) 4 Ereditano i metodi dall’interfaccia e li implementano 4 In questo modo si puo’ definire una famiglia di sottotipi che hanno un’insieme di operazioni comuni

17 17 Interfaccia Iterator (versione semplificata) public interface Iterator { public boolean hasNext ( ); // EFFECTS: restituisce true se ci sono altri // elementi altrimenti false public Object next throws NoSuchElementException; // MODIFIES: this // EFFECTS: se ci sono altri elementi da generare //dà il successivo e modifica lo stato di this, //altrimenti solleva NoSuchElementException (unchecked) }

18 18 Versione semplificata 4 L’interfaccia che usiamo e’ semplificata a scopo didattico 4 Riferiamo alla documentazione di Java per un trattamento completo

19 19 Generatori –un generatore su una data collezione si definisce implementando l’interfaccia Iterator –un generatore si crea, creando un oggetto di quel tipo –tutti i generatori hanno quindi i metodi next ed hasnext che si comportano nello stesso modo (come dichiarato nella superclasse)

20 20 Cosa vedremo? 4 Come si usa un generatore per realizzare l’iterazione astratta su un tipo di dato (dal punto di vista degli altri moduli) 4 Come si implementa l’interfaccia Iterator per iterare su un certo tipo di dato astratto

21 21 Iterazione astratta 4 Per utilizzare generatori per iterare in modo astratto su una collezione, bisogna aggiungere un metodo che ritorna un generatore nella specifica 4 Metodi che ritornano un generatore, spesso chiamati iteratori –da non confondere con il tipo Iterator che restituiscono 4 possono essere anche procedure stand alone –come primesLT100

22 22 Specifica di un iteratore per IntSet public class IntSet { // come prima più public Iterator elements (){ // EFFECTS: ritorna un generatore che produrrà tutti // gli elementi di this (come Integers) ciascuno una // sola volta, in ordine arbitrario // REQUIRES: this non deve essere modificato // finché il generatore è in uso } 4 la clausola REQUIRES impone condizioni sul codice che utilizza il generatore –per questo è messa alla fine –tipica degli iteratori su tipi di dato modificabili

23 23 Specifica di un iteratore stand-alone 1  il metodo primesLT100 public static Iterator primesLT100 () // EFFECTS: restituisce un generatore, // che genera incrementalmente tutti i // numeri primi (Integer) minori di 100

24 24 Specifica di un iteratore stand alone public static Iterator allPrimes () // EFFECTS: ritorna un generatore che produrrà tutti // i numeri primi (come Integers) ciascuno una // sola volta, in ordine arbitrario } 4 il limite al numero di iterazioni deve essere imposto dall’esterno –il generatore può produrre infiniti elementi

25 25 Come si usano?  Il generatore si usa guardando la specifica del corrispondente metodo iteratore public static Iterator primesLT100 () // EFFECTS: restituisce un generatore, // che genera incrementalmente tutti i // numeri primi (Integer) minori di 100

26 26 Come si usano? 4 può essere utilizzato per realizzare un’iterazione astratta: per ogni i prodotto da g esegui a su I // ciclo controllato da hasnext Iterator g = Num.primesLT100 (); while (g.hasNext()) {int i = ((Integer) g.next( )).intValue( ); // esegui a su i }

27 27 Alternativa // ciclo controllato da exception Iterator g = Num.primesLT100(); try {while (true) {int i = ((Integer) g.next()).intValue(); // esegue a su i } catch (NoSuchElementException e) { };

28 28 IntSet public Iterator elements () // EFFECTS: ritorna un generatore che produrrà tutti // gli elementi di this (come Integers) ciascuno una // sola volta, in ordine arbitrario // REQUIRES: this non deve essere modificato // finché il generatore è in uso } Lo possiamo usare per realizzare: public static int setSum (IntSet s) throws NullPointerException // EFFECTS: se s è null solleva // NullPointerException altrimenti // ritorna la somma degli elementi di s

29 29 public static int setSum (IntSet s) throws NullPointerException { Iterator g= s.elements(); int sum = 0; try{while(true) {sum=sum +(Integer) g.next().intvalue();} } catch (NoSuchElementException e) {}} 4 Scritta guardando solo la specifica di IntSet 4 Realizza l’iterazione astratta (indipendente dalla rappresentazione) usando il generatore Procedura stand-alone

30 30 Iteratori 4 Abbiamo visto la specifica e l’uso dei metodi che ritornano un generatore (sottotipo di Iterator) 4 Questi metodi li abbiamo chiamati iteratori 4 Come e dove si definiscono generatori?

31 31 Implementazione degli iteratori e dei generatori  i generatori sono oggetti che hanno come tipo un sottotipo di Iterator –istanze di una classe  che “implementa” l’interfaccia Iterator  un iteratore  è un metodo (stand alone o associato ad un tipo astratto) che ritorna il generatore istanza di   Vogliamo che  acceda alla rappresentazione (deve iterare) senza renderla visibile

32 32 Esempio 4 Il generatore di IntSet deve produrre tutti gli elementi dell’insieme 4 Deve necessariamente poter accedere alla rappresentazione, ovvero al vettore els 4 Quindi non e’ possibile dichiarare la classe come classe separata 4 La classe che definisce il generatore deve essere dichiarata all’interno di IntSet

33 33 Classi nidificate  una classe  dichiarata all’interno di una classe  può essere –static (di proprietà della classe  ) –di istanza (di proprietà degli oggetti istanze di  )  se  è static come sempre non può accedere direttamente le variabili di istanza ed i metodi di istanza di  –le classi che definiscono i generatori si possono quasi sempre definire come inner classes statiche –prendono gli oggetti come parametro

34 34 Classi interne 4 Non descrivere tutti i dettagli 4 Una classe interna statica e privata ha la semantica standard (come se fosse separata) 4 Solo che non e’ visibile da fuori e puo’ accedere alle variabili private della classe che la contiene

35 35 Quindi  Il generatore  deve avere una visibilità limitata al package che contiene l’iteratore  –oppure può essere contenuta nella classe che contiene  come inner class privata  in questo modo i generatori sono visti dall’esterno come oggetti di tipo Iterator –perché il sottotipo  non è visibile

36 36 public Iterator elements () { // EFFECTS: ritorna un generatore che produrrà tutti // gli elementi di this (come Integers) ciascuno una // sola volta, in ordine arbitrario // REQUIRES: this non deve essere modificato // finché il generatore è in uso return new IntSetGen(this);} Intset: iteratore public class IntSet { private Vector els; 4 Ritorna un oggetto di tipo IntSetGen, sottotipo di Iterator, a cui passa l’oggetto corrente 4 Il tipo IntSetGen e’ definito come inner class privata di IntSet, non e’ visibile da fuori dalla classe IntSet

37 37 private static class IntSetGen implements Iterator { private IntSet s; // l’insieme su cui si itera private int next; // prossimo indice del vettore da considerare 4 Manca l’OVERVIEW: il generatore e’ descritto nel corrispondente Iteratore (elements) Le variabili d’istanza mantengono le informazioni per iterare, l’insieme e l’indice del vettore a cui siamo arrivati 4 Nota che la classe e’ interna ad IntSet, ha accesso alle variabili private di IntSet (in particolare del Vector) Intset:generatore 1

38 38 private IntSet s; // l’insieme su cui si itera private int next; // prossimo indice del vettore da considerare public IntSetGen (IntSet it) { // REQUIRES: it != null s = it; next=0; } 4 Costruttore procedura parziale, usata solo all’interno della classe 4 Prende come parametro l’IntSet su cui operare (vedi elements()) Intset:generatore 1

39 39 public boolean hasNext () {if (next>= s.els.size()) {return false;} else {return true;} } public Object next () throws NoSuchElementException { if (next >= s.els.size()) { throw new NoSuchElementException(”IntSet.elements"); } return s.els.get(next); next=next+1;} 4 La specifica dei metodi e’ quella descritta nell’interfaccia (e’ sempre la stessa) Intset:generatore 2

40 40 Implementazione degli iteratori 3 public class Num { public static Iterator allPrimes (){return new PrimesGen();} // EFFECTS: ritorna un generatore che produrrà tutti // i numeri primi (come Integers) ciascuno una // sola volta, in ordine arbitrario private static class PrimeGen implements Iterator { // inner class (classe annidata) private Vector ps; // primi già dati private int p; // prossimo candidato alla generazione PrimesGen () {p = 2; ps = new Vector(); } public boolean hasNext () {return true } public Object next () { if (p == 2) { p = 3; return new Integer(2);} for (int n = p; true; n = n + 2) for (int i = 0; i < ps.size(); i++){ int e1 = ((Integer) ps.get(i)).intValue(); if (n%e1 == 0) break; // non è primo if (e1*e1 > n) {ps.add(new Integer(n); p = n + 2; return new Integer(n);}}} }}

41 41 Classi nidificate e generatori  le classi i cui oggetti sono generatori definiscono comunque dei tipi astratti –sottotipi di Iterator  in quanto tali devono essere dotati di –una funzione di astrazione –un invariante di rappresentazione 4 Necessarie per ragionare sulla loro correttezza

42 42 Funzione di astrazione per i generatori  dobbiamo sapere cosa sono gli stati astratti 4 per tutti i generatori, lo stato astratto è –la sequenza di elementi che devono ancora essere generati –la funzione di astrazione mappa la rappresentazione su tale sequenza

43 43 Funzione di Astrazione: IntSetGen private static class IntSetGen implements Iterator { private IntSet s; // l’insieme su cui si itera private int next; // prossimo indice del vettore da considerare  (c) = [] se c.next>=c.s.els.size() oppure   (c) =[x_i, x_i+1,...,x_n] tale che  c.next= i ed n=c.s.els.size()-1  e per ogni i <= j <=n  xj_ = c.els.get(j) notare che si usano le rep sia di IntSet che di IntSetGen

44 44 Invariante di rappresentazione I (c) = c.s != null e (0 <= c.next <= c.s.els.size()) 4 Il next varia tra 0 e la lunghezza del vettore

45 45 Correttezza dell’iteratore 4 Facciamo vedere che l’invariante di IntSetGen vale 4 Costruttore 4 Metodi per induzione sui dati

46 46 private static class IntSetGen implements Iterator { private IntSet s; // l’insieme su cui si itera private int next; // prossimo indice del vettore da considerare IntSetGen (IntSet it) { // REQUIRES: it != null s = it; next=0; } public boolean hasNext () {if (next > = s.els.size()) {return false;} else {return true;}} 4 I(c) = c.s != null e (0 <= c.next <= c.s.els.size()) Invariante

47 47 private static class IntSetGen implements Iterator { private IntSet s; // l’insieme su cui si itera private int next; // prossimo indice del vettore da considerare public Object next () throws NoSuchElementException { if (next >= s.els.size()) { throw new NoSuchElementException(”IntSet.elements"); } return s.els.get(next); next=next+1;} 4 I(c) = c.s != null e (0 <= c.next <= c.s.els.size()) Vale: se c.next era = c.s.els.size() allora ha sollevato l’eccezione Invariante

48 48 Correttezza del generatore 4 Valgono le invarianti di Intset e di IntSetGen 4 E’ facile convincersi che i metodi next e hasnext() soddisfano la specifica

49 49 Correttezza dell’iteratore 4 il generatore soddisfa anche la specifica (quella richiesta in elements) // EFFECTS: ritorna un generatore che produrrà tutti // gli elementi di this (come Integers) ciascuno una // sola volta, in ordine arbitrario 4 Il generatore ritorna gli elementi del vettore che rappresenta l’insieme 4 E’ corretto perche’: (1) non ci sono occorrenze multiple nel vettore; (2) gli elementi del vettore sono Integer 4 Queste proprieta’ sono garantite dall’invariante di IntSet

50 50 Conclusioni sugli iteratori 4 in molti tipi di dato astratti (collezioni) gli iteratori sono un componente essenziale –supportano l’astrazione via specifica –portano a programmi efficienti in tempo e spazio –sono facili da usare –non distruggono la collezione –ce ne possono essere più d’uno 4 se il tipo di dato astratto è modificabile ci dovrebbe sempre essere il vincolo sulla non modificabilità del dato durante l’uso dell’iteratore –altrimenti è molto difficile specificarne il comportamento previsto –in alcuni casi può essere utile combinare generazioni e modifiche