1 Progettare un Tipo di Dato Astratto. 2 Scelte di Progetto (astrazione) 4 Caratteristiche degli oggetti –Modificabilità 4 Scelta delle operazioni –Realizzare.

Presentazione sul tema: "1 Progettare un Tipo di Dato Astratto. 2 Scelte di Progetto (astrazione) 4 Caratteristiche degli oggetti –Modificabilità 4 Scelta delle operazioni –Realizzare."— Transcript della presentazione:

1 1 Progettare un Tipo di Dato Astratto

2 2 Scelte di Progetto (astrazione) 4 Caratteristiche degli oggetti –Modificabilità 4 Scelta delle operazioni –Realizzare le possibili richieste degli utenti –Efficienza 4 Ricordiamo che deve essere possibile accedere ai tipi di dato astratto solo attraverso le operazioni per avere l’indipendenza dall’implementazione

3 3 Modificabilità? 4 i tipi non modificabili sono più sicuri –la condivisione di sottostrutture non crea problemi nell’implementazione –i tipi non modificabili sono spesso più inefficienti –la necessità di costruire spesso copie di oggetti può complicare la vita al garbage collector 4 la scelta dovrebbe comunque tener conto delle caratteristiche dei concetti matematici o degli oggetti del mondo reale modellati dal tipo –gli interi non sono modificabili –gli insiemi sono modificabili –i conti correnti sono modificabili

4 4 Un esempio 4 Ambiente dei metodi e del Frame (dell’interprete di Java) 4 Sono funzioni simili: Menv = Id -> Mdescr Frame= Id -> Val

5 5 Ma….. 4 Il valore associato ad una variabile viene cambiato a seguito di un assegnamento 4 Ambiente dei metodi: non modificabile 4 Frame: modificabile

6 6 L’ambiente di metodi 4 Ambiente dei metodi Menv = Id -> Mdescr Mdescr = Idlist * Blocco * ( Loc | Id ) –memptyenv() –mbind((  :Menv), (i:Id), (m:Mdescr)) –mdefined ((  :Menv), (i:Id)) –instantiate((  :Menv), (l: Loc)) –Applicazione Non c’e’ una operazione di update!

7 7 L’ambiente di metodi: specifica public class MethodEnv { // OVERVIEW: un MethodEnv è una // funzione parziale da identificatori // di metodi (stringhe) a descrizioni di // metodi. Non è modificabile. // costruttore public MethodEnv () // EFFECTS: costruisce un nuovo // MethodEnv indefinito per tutti // gli identificatori

8 8 L’ambiente di metodi 2 public boolean defined (String s) // EFFECTS: se this è definita per // l'identificatore s ritorna true // altrimenti ritorna false

9 9 L’ambiente di metodi 3 public Mdescr apply (String s) throws Undefined // EFFECTS: se la funzione this è // definita per l'identificatore x // restituisce this(s) altrimenti // solleva l'eccezione (unchecked) // Undefined

10 10 L’ambiente di metodi 4 public MethodEnv bind (String s, Mdescr m) // EFFECTS: restituisce una funzione // diversa da this solo perché se // applicata ad s restituisce m Notate che non modifica l’ambiente dei metodi!

11 11 L’ambiente di metodi 5 public MethodEnv instantiate (ClassorObject o) throws NonObjectException // EFFECTS: restituisce una funzione // diversa da this solo perché per ogni // nome restituisce una descrizione di // metodo nuova contenente l'oggetto o // se o non e' un oggetto solleva // NonObjectException (unchecked)

12 12 Di che altri tipi abbiamo bisogno? 4 le descrizioni di metodo –Mdescr = Idlist * Blocco * ( Loc | Id ) –Mdescr 4 l’identificatore di classe o oggetto –( Loc | Id ) –ClassorObject 4 i due exception types (unchecked) –NonObjectException –Undefined

13 13 I tipi eccezione 4 i due exception types (unchecked) –NonObjectException –Undefined public class NonObjectException extends RuntimeException { // costruttore public NonObjectException (String s) {super (s); } }

14 14 I tipi eccezione 4 i due exception types (unchecked) –NonObjectException –Undefined public class Undefined extends RuntimeException { // costruttore public Undefined (String s) {super (s); } }

15 15 L’identificatore di classe o oggetto 1 –ClassorObject –( Loc | Id ) Lo progettiamo in modo da avere tutte le operazioni che servono nell’interprete!

16 16 L’identificatore di classe o oggetto 1 –ClassorObject –( Loc | Id ) public class ClassorObject { // un ClassorObject è un oggetto che può // essere un identificatore di classe // (stringa), un identificatore di // oggetto (Loc) o indefinito

17 17 L’identificatore di classe o oggetto 2... // 3 costruttori overloaded public ClassorObject () // EFFECTS: costruisce un ClassorObject // indefinito public ClassorObject (String x) // EFFECTS: costruisce un ClassorObject // che contiene la classe x public ClassorObject (Loc x) // EFFECTS: costruisce un ClassorObject // che contiene l’oggetto x

18 18 L’identificatore di classe o oggetto 3 public boolean isClass () // EFFECTS: se this è un identificatore // di classe restituisce true altrimenti // restituisce false public boolean isUndefined () // EFFECTS: se this è indefinito // restituisce true altrimenti // restituisce false public boolean isObject () // EFFECTS: se this è un oggetto // restituisce true altrimenti // restituisce false }

19 19 Di che altri tipi abbiamo bisogno?  le locazioni (identificatori di oggetti) –Loc public class Loc { // Loc contiene un intero che permette // di indirizzare una heap: ha uno stato // interno che permette di generare // valori sempre diversi

20 20 Le locazioni // costruttore public Loc () // EFFECTS: costruisce una nuova Loc // MODIFIES: lo stato interno // metodi public int key () // restituisce il valore contenuto in // this }

21 21 Le descrizioni di metodo 4 le descrizioni di metodo –Mdescr = Idlist * Blocco * ( Loc | Id ) –Mdescr 4 lo realizziamo direttamente con un record type –Idlist e Blocco sono stringhe –il terzo campo è un ClassorObject

22 22 Le descrizioni di metodo 1 public class Mdescr { // OVERVIEW: un Mdescr è un record type // che contiene tutta l’informazione // associata ad un metodo String parameters; String body; ClassorObject belongsto; Notate che la rappresentazione e la specifica coincidono!

23 23 Le descrizioni di metodo 2 // costruttore public Mdescr (String x, String y, ClassorObject z) // EFFECTS: costruisce un record // contenente i tre argomenti {parameters = x; body = y; belongsto = z;} }

24 24 Lo stato della progettazione 4 classi specificate e implementate (eccezioni e record types) –Mdescr –NonObjectException –Undefined 4 classi specificate –ClassorObject –Loc –MethodEnv

25 25 La relazione “chi usa chi” a livello di specifica MethodEnv MdescrUndefined ClassorObject Loc NonObjectException

26 26 Come continuare 4 le classi da implementare –ClassorObject –Loc –MethodEnv 4 possono essere implementate in un ordine qualunque –Loc –ClassorObject –MethodEnv

27 27 Implementazione di Loc 1 public class Loc { // Loc contiene un intero che permette // di indirizzare una heap: ha uno stato // interno che permette di generare // valori sempre diversi private static int stato = 0; private int chiave;  chiave è il valore “contenuto”,  stato è lo stato interno (static), rappresentato dalla prima locazione libera

28 28 Implementazione di Loc 2 // costruttore public Loc () // EFFECTS: costruisce una nuova Loc // MODIFIES: lo stato interno { chiave = stato; stato = stato + 1; return; }

29 29 Implementazione di Loc 3 // metodi public int key () // restituisce il valore contenuto in // this { return chiave; } }

30 30 Implementazione di ClassorObject 1 public class ClassorObject { // un ClassorObject è un oggetto che può // essere un identificatore di classe // (stringa), un identificatore di // oggetto (Loc) o indefinito private Object v;  lo stato è una variabile di tipo Object, puo’ contenere sia Loc che String

31 31 Implementazione di ClassorObject 2 public ClassorObject () // EFFECTS: costruisce un ClassorObject // indefinito { } public ClassorObject (String x) // EFFECTS: costruisce un ClassorObject // che contiene la classe x { v = x; } public ClassorObject (Loc x) // EFFECTS: costruisce un ClassorObject // che contiene l’oggetto x { v = x; }

32 32 Implementazione di ClassorObject 3 public boolean isClass () // EFFECTS: se this è un identificatore // di classe restituisce true altrimenti // restituisce false {if (isUndefined()) return false; String s; try {s = (String) v;} catch (Exception e) {return false; } return true; }  utilizziamo le eccezioni (mascherate) per fare un’analisi di casi sul tipo

33 33 Implementazione di ClassorObject 4 public boolean isUndefined () // EFFECTS: se this è indefinito // restituisce true altrimenti // restituisce false { if (v == null) return true; else return false; }

34 34 Implementazione di ClassorObject 5 public boolean isObject () // EFFECTS: se this è un oggetto // restituisce true altrimenti // restituisce false {if (isUndefined()) return false; Loc l; try {l = (Loc) v;} catch (Exception e) {return false;} return true;} }

35 35 Implementazione di MethodEnv public class MethodEnv { // OVERVIEW: un MethodEnv è una // funzione parziale da identificatori // di metodi (stringhe) a descrizioni di // metodi. Non è modificabile.  decidiamo di rappresentare le funzioni con arrays i cui elementi sono coppie ( String, Mdescr ) –specifichiamo quindi per prima cosa un tipo record PairIdeVal un po’ più generale di quello che ci serve

36 36 Specifica ed implementazione di PairIdeVal public class PairIdeVal { // OVERVIEW: un PairIdeVal è un record // type che contiene una associazione // tra nome e valore String nome; Object valore; // costruttore public PairIdeVal (String x, Object z) // EFFECTS: costruisce un record // contenente i due argomenti {nome = x; valore = z;} } un po’ più generale di quello che ci serve –i valori sono Object e non Mdescr

37 37 La relazione “chi usa chi” a livello di specifica e di implementazione MethodEnv MdescrUndefined ClassorObject Loc NonObjectException PairIdeVal

38 38 Implementazione di MethodEnv 1 public class MethodEnv { // OVERVIEW: un MethodEnv è una // funzione parziale da identificatori // di metodi (stringhe) a descrizioni di // metodi. Non è modificabile. private PairIdeVal[] associazioni;

39 39 Implementazione di MethodEnv 2 // costruttore pubblico public MethodEnv () // EFFECTS: costruisce un nuovo // MethodEnv indefinito per tutti // gli identificatori {associazioni = new PairIdeVal[0];}

40 40 Costruttori privati ausiliari 4 Non stanno nella specifica 4 Il primo prende come argomento un array di PairIdeVal e costruisce un array (copia) che condivide gli stessi valori  Il secondo costruisce un array di PairIdeVal di lunghezza fissata 4 Il primo prende come argomento un array di PairIdeVal e costruisce un array (copia) che condivide gli stessi valori ed ha in piu’ una posizione vuota

41 41 Costruttori privati ausiliari (non stanno nella specifica) // altri costruttori privati private MethodEnv (PairIdeVal[] m) // EFFECTS: costruisce una nuova // funzione la cui rappresentazione // è m {associazioni = new PairIdeVal[m.length]; if (m.length == 0) return ; for (int i = 0; i < m.length; i++) { associazioni[i] = m[i];;} }

42 42 Implementazione di MethodEnv 4 // altri costruttori privati private MethodEnv (int n) // EFFECTS: costruisce una nuova // funzione la cui rappresentazione // è un array vuoto lungo n {associazioni = new PairIdeVal[n];}

43 43 Implementazione di MethodEnv 5 // altri costruttori privati private MethodEnv (PairIdeVal[] m, int n) // REQUIRES: n = m.length+1 // EFFECTS: costruisce una nuova // funzione la cui rappresentazione // è un array uguale ad m più una // posizione vuota {associazioni = new PairIdeVal[n]; if (m.length == 0) return ; for (int i = 0; i < m.length; i++) { associazioni[i] =m[i];;} }

44 44 Implementazione di MethodEnv 6 public boolean defined (String s) // EFFECTS: se this è definita per // l'identificatore s ritorna true // altrimenti ritorna false {if (associazioni.length == 0) return false; for (int i = 0; i < associazioni.length; i++) { PairIdeVal p = associazioni[i]; if (s.equals(p.nome)) return true;} return false;}

45 45 Implementazione di MethodEnv 7 public Mdescr apply (String s) throws Undefined // EFFECTS: se la funzione this è // definita per l'identificatore x // restituisce this(s) altrimenti // solleva l'eccezione (unchecked) // Undefined {for (int i = 0; i < associazioni.length; i++) { PairIdeVal p = associazioni[i]; if (s.equals(p.nome)) return (Mdescr) p.valore;} throw new Undefined("Methodenv.apply");}

46 46 Implementazione di MethodEnv 8 public MethodEnv bind (String s, Mdescr m) // EFFECTS: restituisce una funzione diversa da this // solo perché se applicata ad s restituisce m {MethodEnv nuovo; PairIdeVal newass = new PairIdeVal(s,m); if (defined(s)) {nuovo = new MethodEnv(associazioni); for (int i = 0; i < nuovo.associazioni.length; i++) {PairIdeVal p = nuovo.associazioni[i]; if (s.equals(p.nome)) nuovo.associazioni[i] = newass;} return nuovo;} …. // Se era gia’ presente deve sovrascriverlo (overriding)

47 47 Implementazione di MethodEnv 8 // Se non era definito, deve allungare al’array ed inserire la nuova coppia else {if (associazioni.length == 0) {nuovo = new MethodEnv(1);} else {nuovo = new MethodEnv(associazioni, associazioni.length + 1);} nuovo.associazioni[associazioni.length] = newass; return nuovo;}

48 48 Implementazione di MethodEnv 9 public MethodEnv instantiate (ClassorObject o) throws NonObjectException // EFFECTS: restituisce una funzione diversa da this // solo perché per ogni nome restituisce una // descrizione di metodo nuova contenente l'oggetto o // se o non e' un oggetto solleva NonObjectException // (unchecked) {MethodEnv nuovo = new MethodEnv(associazioni); if (o.isObject()) { for (int i = 0; i < associazioni.length; i++) { Mdescr vecchia = (Mdescr) associazioni[i].valore; Mdescr nuova = new Mdescr(vecchia.parameters,vecchia.body,o); PairIdeVal newass = new PairIdeVal(associazioni[i].nome,nuova); nuovo.associazioni[i] = newass;} return nuovo;} else {throw new NonObjectException("MethodEnv.instantiate");}}

49 49 Quello che dovete fare 4 Modificabile Frame = Id -> Val Val = (Bool | Int | Loc) –newframe() –copy((  :Frame)) –bind((  :Frame), (i:Id), (v:Val)) –update((  :Frame), (i:Id), (v:Val)) –defined((  :Frame), (i:Id))

50 50 Differenze 4 Bind ed update sono metodi modificatori (modificano this): piu’ efficienti rispetto al caso di MethodEnv 4 Il metodo bind differisce perche’ richiede che l’identificatore per cui inseriamo l’associazione non sia gia’ definito nel frame (non c’e’ overriding!)

51 51 Copia del Frame 4 E’ necessario pero’ un metodo copy 4 Quando creiamo un oggetto estendendo il frame della superclasse dobbiamo copiare il frame della superclasse 4 E’ modificabile, a differenza di MethodEnv, non possiamo condiverli 4 Attenzione all’implementazione di copy, le possibili modifiche su uno dei due frame devono essere invisibili sull’altro.