1 Astrazioni sui dati : Specifica ed Implementazione di Tipi di Dato Astratti in Java

2 Sommario 4 cos’è un tipo di dato astratto 4 astrazione tramite specifica: 1. specifica 2. implementazione 3. relazione tra specifica ed implementazione (nel seguito)

3 Perché l’astrazione sui dati 4 il più importante tipo di astrazione 4 il nucleo della programmazione orientata ad oggetti 4 lo scopo è quello di estendere il linguaggio –nel nostro caso, Java con nuovi tipi di dato (oltre a quelli primitivi int, String…) 4 quali, dipende dall’applicazione interprete: stacks e tabelle di simboli (frame, ambiente dei metodi) applicazione bancaria: conti applicazioni numeriche: matrici

4 Cos’è un tipo di dato astratto 4 in ogni caso è –un insieme di dati stacks, conti, matrici –+ un insieme di operazioni per crearli e manipolarli 4 Cosa sta nella specifica? La descrizione astratta dei dati La descrizione delle relative operazioni

5 Implementazione 4 Cosa sta nell’ implementazione? La rappresentazione (o implementazione) dei dati L’implementazione delle relative operazioni Notate che vedere nella specifica insieme oggetti ed operazioni e’ necessario per realizzare in modo proficuo l’astrazione tramite specifica

6 Astrazione sui dati via specifica 4 con la specifica vogliamo astrarre dall’implementazione del tipo di dato –l’utente deve operare sul tipo di dato indipendendentemente dalla sua rappresentazione 4 Se la specifica non contenesse la descrizione astratta dei data, l’utente vedrebbe direttamente la loro rappresentazione 4 Di conseguenza le modifiche della rappresentazione comporterebbero modifiche dei moduli che usano il tipo di dato

7 Astrazione sui dati via specifica 4 vedendo gli oggetti insieme alle operazioni, l’astrazione diventa possibile –la rappresentazione è nascosta all’utente esterno che accede ai dati solo tramite le operazioni (senza sapere come sono implementate) –la rappresentazione è visibile all’implementazione delle operazioni –Di conseguenza se una rappresentazione viene modificata, devono essere modificate le implementazioni delle operazioni, ma non i moduli che la utilizzano è il tipo di modifica più comune durante la manutenzione

8 Come procediamo? 4 Prima definiamo la specifica del tipo di dato astratto –Interfaccia con l’utente 4 Poi la implementiamo –Puo’ al solito essere fatto in un momento successivo, in modo indipendente dai moduli che usano il tipo di dato

9 Gli ingredienti della specifica di un tipo di dato astratto 4 Java (parte sintattica della specifica) –classe o interfaccia per ora solo classi –nome per il tipo nome della classe –operazioni metodi di istanza incluso il(i) costruttore(i) 4 la specifica del tipo descrive proprietà generali degli oggetti –per esempio la modicabilità 4 per il resto la specifica è essenzialmente una specifica dei metodi –strutturata come già abbiamo visto per le astrazioni procedurali –l’oggetto su cui i metodi operano è indicato nella specifica da this

10 Formato della specifica public class NuovoTipo { // OVERVIEW: Gli oggetti di tipo NuovoTipo // sono collezioni modificabili di.. // costruttori public NuovoTipo () // EFFECTS:... // metodi // specifiche degli altri metodi }

11 L’insieme di interi 1 public class IntSet { // OVERVIEW: un IntSet è un insieme modificabile // di interi di dimensione qualunque // 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...}

12 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 }

13 IntSet : commenti 1 public class IntSet { // OVERVIEW: un IntSet è un insieme modificabile // di interi di dimensione qualunque.... } 4 gli oggetti della classe sono descritti nella specifica in termini di concetti noti –in questo caso, gli insiemi matematici 4 gli stessi concetti sono anche utilizzati nella specifica dei metodi –aggiungere, togliere elementi –appartenenza, cardinalità

14 IntSet : commenti 2 public class IntSet { // OVERVIEW:... // costruttore public IntSet () // EFFECTS: inizializza this a vuoto...} 4 un solo costruttore (senza parametri) –inizializza this (l’oggetto nuovo) –non è possibile vedere lo stato dell’oggetto tra la creazione e l’inizializzazione la specifica non ha una clausola MODIFIES

15 IntSet : commenti 3 public class IntSet {... // 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...} 4 modificatori –modificano lo stato del proprio oggetto ( MODIFIES: this ) –notare che nè insert nè remove sollevano eccezioni se si inserisce un elemento che c’è già se si rimuove un elemento che non c’è

16 IntSet : commenti 4 public boolean isIn (int x) // EFFECTS: se x appartiene a this ritorna // true, altrimenti false 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...} 4 osservatori –non modificano lo stato del proprio oggetto –choose può sollevare un’eccezione (se l’insieme è vuoto) EmptyException può essere unchecked, perché l’utente può utilizzare size per evitare di farla sollevare choose è sottodeterminata (implementazioni corrette diverse possono dare diversi risultati)

17 Astrazione tramite specifica La specifica contiene tutte e sole le informazioni per utilizzare il tipo di dato in altri moduli –Possiamo scrivere codice che crea oggetti di quel tipo e li modifica tramite metodi e costruttori –Se aggiungiamo corpi contenenti return ben-tipati alla specifica dei metodi »la specifica può essere compilata »possono essere compilate implementazioni di moduli che la utilizzano (errori rilevati subito dall’analisi statica)

18 Esempio di un metodo che usa IntSet public static IntSet getElements (int[] a) throws NullPointerException // EFFECTS: a=null solleva NullPointerException // altrimenti, restituisce un insieme che contiene // tutti e soli gli interi presenti in a {IntSet s = new IntSet(); for (int i = 0; i < a.length; i++) s.insert(a[i]); return s; }  scritta solo conoscendo la specifica di IntSet

19 Notate che –non accede all’implementazione non esiste ancora anche se ci fosse non potrebbe “vederla” –costruisce, accede e modifica l’oggetto solo attraverso i metodi (incluso il costruttore)

20 Specifica di un tipo “primitivo” 4 le specifiche sono ovviamente utili per capire ed utilizzare correttamente i tipi di dato “primitivi” di Java 4 vedremo, come esempio, il caso dei vettori –Vector –arrays dinamici che possono crescere e accorciarsi –contengono Object ( per il principio di sostituzione possiamo metterci qualsiasi oggetto, non direttamente int, bool e char)

21 Specifica di un tipo “primitivo” –La specifica e’ di fatto la descrizione che troviamo nel manuale (a parte il formato dei commenti) –Quando usiamo il tipo di dato primitivo non sappiamo come e’ realizzato, ovvero come e’rappresentato il Vector e come sono realizzate le operazioni relative –Lo stesso meccanismo di astrazione tramite specifica deve valere per i tipi di dato astratti che definiamo

22 Vector 1 public class Vector { // OVERVIEW: un Vector è un array modificabile // di dimensione variabile i cui elementi sono // di tipo Object: indici tra 0 e size - 1 // costruttore public Vector () // EFFECTS: inizializza this a vuoto // metodi public void add (Object x) // MODIFIES: this // EFFECTS: aggiunge una nuova posizione a // this inserendovi x public int size () // EFFECTS: ritorna il numero di elementi di // this...}

23 Vector 2... public Object get (int n) throws IndexOutOfBoundsException // EFFECTS: se n = this.size solleva // IndexOutOfBoundsException, altrimenti // ritorna l’oggetto in posizione n in this public void set (int n, Object x) throws IndexOutOfBoundsException // MODIFIES: this // EFFECTS: se n = this.size solleva // IndexOutOfBoundsException, altrimenti // modifica this sostituendovi l’oggetto x in // posizione n}

24 Vector 3... public void remove (int n) throws IndexOutOfBoundsException // MODIFIES: this // EFFECTS: se n = this.size solleva // IndexOutOfBoundsException, altrimenti // modifica this eliminando l’oggetto in // posizione n public void insert (Object o, int n) throws IndexOutOfBoundsException // MODIFIES: this // EFFECTS: se n = this.size solleva // IndexOutOfBoundsException, altrimenti // modifica this inserendo o nella posizione n }

25 Vector : commenti 1 public class Vector { // OVERVIEW: un Vector è un array modificabile // di dimensione variabile i cui elementi sono // di tipo Object: indici tra 0 e size } 4 gli oggetti della classe sono descritti nella specifica in termini di concetti noti –in questo caso, gli arrays 4 gli stessi concetti sono anche utilizzati nella specifica dei metodi –indice, elemento identificato dall’indice 4 il tipo è modificabile (come l’array) 4 notare che gli elementi sono di tipo Object –Per il principio di sostituzione possiamo mettterci per esempio, non possono essere int, bool e char

26 Vector : commenti 2 public class Vector { // OVERVIEW: un Vector è un array modificabile // di dimensione variabile i cui elementi sono // di tipo Object: indici tra 0 e size - 1 // costruttore public Vector () // EFFECTS: inizializza this a vuoto...} 4 un solo costruttore (senza parametri) –inizializza this (l’oggetto nuovo) ad un “array” vuoto

27 Vector : commenti 3 public void add (Object x) // MODIFIES: this // EFFECTS: aggiunge una nuova posizione a // this inserendovi x public void set (int n, Object x) throws IndexOutOfBoundsException // MODIFIES: this // EFFECTS: se n = this.size solleva // IndexOutOfBoundsException, altrimenti modifica // this sostituendovi l’oggetto x in posizione n 4 sono modificatori –modificano lo stato del proprio oggetto ( MODIFIES: this ) –set e remove possono sollevare un’eccezione primitiva unchecked

28 Vector : commenti 3 public void remove (int n) throws IndexOutOfBoundsException // MODIFIES: this // EFFECTS: se n = this.size solleva // IndexOutOfBoundsException, altrimenti modifica // this eliminando l’oggetto in posizione n public void insert (Object o, int n) throws IndexOutOfBoundsException // MODIFIES: this // EFFECTS: se n = this.size solleva // IndexOutOfBoundsException, altrimenti // modifica this inserendo o nella posizione n 4 sono modificatori 4 In entrambi i casi vengono shiftati gli elementi che occorrono dopo la posizione n, in indietro o avanti

29 Vector : commenti 4 public int size () // EFFECTS: ritorna il numero di elementi di // this public Object get (int n) throws IndexOutOfBoundsException // EFFECTS: se n = this.size solleva // IndexOutOfBoundsException, altrimenti // ritorna l’oggetto in posizione n in this public Object lastElement () // EFFECTS: ritorna l’ultimo oggetto in this 4 sono osservatori –non modificano lo stato del proprio oggetto –get può sollevare un’eccezione primitiva unchecked

30 Vector Altri metodi rimandiamo alla specifica del manuale

31 Un tipo di dato non modificabile public class Poly { // OVERVIEW: un Poly è un polinomio a // coefficienti interi non modificabile // esempio: c 0 + c 1 *x + c 2 *x // costruttori public Poly () // EFFECTS: inizializza this al polinomio 0 public Poly (int c, int n) throws NegativeExponentExc // EFFECTS: se n<0 solleva NegativeExponentExc // altrimenti inizializza this al polinomio cx n // metodi...}

32 I polinomi 2 public class Poly {... // metodi public int degree () // EFFECTS: ritorna 0 se this è il polinomio // 0, altrimenti il più grande esponente con // coefficiente diverso da 0 in this public int coeff (int d) // EFFECTS: ritorna il coefficiente del // termine in this che ha come esponente d public Poly add (Poly q) throws NullPointerException // EFFECTS: q=null solleva NullPointerException // altrimenti ritorna this + q...}

33 I polinomi 3 public class Poly {... // metodi... public Poly mul (Poly q) throws NullPointerException // EFFECTS: q=null solleva NullPointerException // altrimenti ritorna this * q public Poly sub (Poly q) throws NullPointerException // EFFECTS: q=null solleva NullPointerException // altrimenti ritorna this - q public Poly minus () // EFFECTS: ritorna -this }

34 Poly : commenti 1 public class Poly { // OVERVIEW: un Poly è un polinomio a // cofficienti interi non modificabile // esempio: c 0 + c 1 *x + c 2 *x } 4 gli oggetti della classe sono descritti nella specifica in termini di concetti noti –in questo caso, i polinomi 4 gli stessi concetti sono anche utilizzati nella specifica dei metodi –operazioni di +, *, e -

35 Poly : commenti 2 public class Poly { // OVERVIEW:... // costruttori public Poly () // EFFECTS: inizializza this al polinomio 0 public Poly (int c, int n) throws NegativeExponentExc // EFFECTS: se n<0 solleva NegativeExponentExc // altrimenti inizializza this al polinomio cx n...} 4 due costruttori overloaded –stesso nome (quello della classe, in questo caso) –diverso numero o tipo di parametri se no, errore di compilazione –la scelta tra metodi overloaded viene effettuata in base al numero e tipo di parametri eventualmente a run time scegliendo il più specifico

36 Poly : commenti 3 public class Poly { // OVERVIEW:... // costruttori public Poly () // EFFECTS: inizializza this al polinomio 0 public Poly (int c, int n) throws NegativeExponentExc // EFFECTS: se n<0 solleva NegativeExponentExc // altrimenti inizializza this al polinomio cx n...}  l’eccezione NegativeExponentExc non è definita qui –nello stesso package di Poly ? –può essere unchecked, perché non è probabile che l’utente usi esponenti negativi

37 Poly : commenti 4 // metodi public int degree () // EFFECTS: ritorna 0 se this è il polinomio // 0, altrimenti il più grande esponente con // coefficiente diverso da 0 in this public int coeff (int d) // EFFECTS: ritorna il coefficiente del // termine in this che ha come esponente d public Poly add (Poly q) throws NullPointerException // EFFECTS: q=null solleva NullPointerException // altrimenti ritorna this + q... 4 non ci sono modificatori –il tipo è non modificabile! –degree e coeff sono osservatori –add, mul, sub e minus ritornano nuovi oggetti di tipo Poly

38 Implementazione 4 scelta fondamentale è quella della rappresentazione (rep) –come i valori del tipo astratto sono implementati in termini di altri tipi tipi primitivi o già implementati nuovi tipi astratti che facilitano l’implementazione del nostro –tali tipi vengono specificati –la scelta deve tener nel dovuto conto la possibilità di implementare in modo efficiente i costruttori e gli altri metodi 4 poi viene l’implementazione dei costruttori e dei metodi (più eventuali altri metodi ausiliari privati)

39 La rappresentazione 4 in Java, gli oggetti del nuovo tipo sono semplicemente collezioni di valori di altri tipi –definite (nella implementazione della classe) da un insieme di variabili di istanza private accessibili solo dai costruttori e dai metodi della classe questo e’ necessario per evitare l’accesso diretto alla rappresentazione dell’oggetto da parte degli utenti

40 Usi “corretti” delle classi in Java 4 nella definizione di astrazioni procedurali –le classi contengono essenzialmente metodi statici eventuali variabili statiche possono servire per avere dati condivisi fra le varie attivazioni dei metodi –procedure con stato interno variabili e metodi di istanza (inclusi i costruttori) non dovrebbero esistere, perchè la classe non sarà mai usata per creare oggetti 4 nella definizione di astrazioni sui dati –le classi contengono essenzialmente metodi di istanza e variabili di istanza private eventuali variabili statiche possono servire per avere informazione condivisa fra oggetti diversi eventuali metodi statici non possono comunque vedere l’oggetto e servono solo a manipolare le variabili statiche

41 Implementazione di IntSet 1 public class IntSet { // OVERVIEW: un IntSet è un insieme modificabile // di interi di dimensione qualunque private Vector els; // la rappresentazione // costruttore public IntSet () // EFFECTS: inizializza this a vuoto {els = new Vector();}...}  un insieme di interi è rappresentato da un Vector –più adatto dell’ Array, perché l’insieme ha dimensione variabile  gli elementi di un Vector sono di tipo Object –non possiamo memorizzarci valori di tipo int –usiamo oggetti di tipo Integer interi visti come oggetti tramite conversione

42 Implementazione di IntSet 2 public void insert (int x) // MODIFIES: this // EFFECTS: aggiunge x a this {Integer y = new Integer(x); if (getIndex(y) < 0) els.add(y); } 4 Inseriamo l’elemento solo se non occorre gia’ nell’insieme 4 Vogliamo che non ci siano occorrenze multiple di elementi –implementazione piu’ efficiente (vedi remove e size) 4 A tale fine si utilizza un metodo ausiliario getIndex, che ritorna -1 se l’elemento non occorre

43 Implementazione di IntSet 2 private int getIndex (Integer x) // EFFECTS: se x occorre in this ritorna la // posizione in cui si trova, altrimenti -1 {for (int i = 0; i < els.size(); i++) if (x.equals(els.get(i))) return i; return -1; }  il metodo privato ausiliario getIndex ritorna un valore speciale e non solleva eccezioni 4 non sta nella specifica (va bene perché è privato)  notare l’uso del metodo equals su Integer

44 Implementazione di IntSet 3 public void remove (int x) // MODIFIES: this // EFFECTS: toglie x da this {int i = getIndex(new Integer(x)); if (i < 0) return; els.set(i, els.lastElement()); els.remove(els.size() - 1);} 4 nella rimozione, se l’elemento c’è, ci scrivo sopra l’ultimo corrente ed elimino l’ultimo elemento 4 E’ corretto sse l’elemento occorre in una sola posizione del vettore………

45 Implementazione di IntSet 3 public boolean isIn (int x) // EFFECTS: se x appartiene a this ritorna // true, altrimenti false { return getIndex(new Integer(x)) >= 0; } 4 Usa il solito metodo ausiliario

46 Implementazione di IntSet 4 public int size () // EFFECTS: ritorna la cardinalità di this {return els.size(); } 4 E’ corretto sse non ci possono essere occorrenze multiple di elementi nel vettore

47 Implementazione di IntSet 4 public int choose () throws EmptyException // EFFECTS: se this è vuoto, solleva // EmptyException, altrimenti ritorna un // elemento qualunque contenuto in this {if (els.size() == 0) throw new EmptyException(“IntSet.choose”); return ((Integer) els.lastElement()).intValue(); }  lastElement non puo’ sollevare eccezioni dato che si effettua un controllo che non sia vuoto 4 ritorna un Object (come tipo apparente), quindi per trasformarlo in int tramite intValue() bisogna fare il cast

48 Prima implementazione di Poly 1 public class Poly { // OVERVIEW: un Poly è un polinomio a // cofficienti interi non modificabile // esempio: c 0 + c 1 *x + c 2 *x private int[] termini; // la rappresentazione private int deg; // la rappresentazione 4 i polinomi non cambiano la dimensione –Array invece che Vector –l’elemento in posizione n contiene il coefficiente del termine che ha esponente n (eventualmente 0) –Array ha la dimensione del grado del polinomio per comodità (efficienza) ci teniamo traccia nella rappresentazione del grado (degree) del polinomio –variabile di tipo int

49 Costruttori // costruttori public Poly () // EFFECTS: inizializza this al polinomio 0 {termini = new int[1]; deg = 0; } public Poly (int c, int n) throws NegativeExponentExc // EFFECTS: se n<0 solleva NegativeExponentExc // altrimenti inizializza this al polinomio cx n if (n < 0) throw new NegativeExponentExc (“Poly(int,int) constructor”); if (c == 0) {termini = new int[1]; deg = 0; return; } termini = new int[n+1]; for (int i = 0; i < n; i++) termini[i] = 0; termini[n] = c; deg = n; } 4 il polinomio vuoto è rappresentato da un array di un elemento contenente 0

50 Costruttori private Poly (int n) {termini = new int[n+1]; deg = n; } 4 un costruttore privato di comodo (crea un array di dimensione n) 4 Non sta nella specifica non è infatti visibile da fuori (lo usiamo dopo……..)

51 Prima implementazione di Poly 3 public int degree () // EFFECTS: ritorna 0 se this è il polinomio // 0, altrimenti il più grande esponente con // coefficiente diverso da 0 in this {return deg; } public int coeff (int d) // EFFECTS: ritorna il coefficiente del // termine in this che ha come esponente d {if (d deg) return 0; else return termini[d];}

52 Prima implementazione di Poly 3 public Poly minus () // EFFECTS: ritorna -this {Poly y = new Poly(deg); for (int i = 0; i < deg; i++) y.termini[i] = - termini[i]; return y;} public Poly sub (Poly q) throws NullPointerException // EFFECTS: se q=null solleva NullPointerException // altrimenti ritorna this - q {return add(q.minus()); } 4 Notare l’uso del costruttore privato Poly (ausiliario)

53 Prima implementazione di Poly 4 4 più complesse –ma solo negli aspetti algoritmici –le implementazioni di add e mul che non mostriamo 4 se i polinomi sono sparsi –questa implementazione non è efficiente arrays grandi e pieni di 0 –Vediamo una implementazione alternativa in cui solo coefficienti non 0 sono rappresentati

54 Seconda implementazione di Poly – Utilizzare due Vector i cui elementi contengono coefficienti ed esponenti rispettivamente Private Vector coeffs;//coefficienti non-zero Private Vector exps;// esponenti associati – Poco efficiente, difficile garantire che l’esponente nella n-esima posizione sia proprio quello dell’n-esimo coefficiente

55 Soluzione alternativa – Utilizzare un Vector i cui elementi sono coppie del tipo (esponente, coefficiente) –Come rappresentare le coppie? –Tipo di dato record, permette di definire una collezione di campi con un tipo ed un nome –I record sono tipi di dato primitivi in molti Linguaggi di Programmazione, non in Java

56 4 Java non ha un meccanismo primitivo per definire tipi record –ma è facilissimo definirli Variabili d’istanza per ogni campo non ci sono metodi, si accede direttamente ai campi di fatto non c’è specifica separata dall’implementazione (non ha senso astrarre!) La rappresentazione e’ visibile Record in Java

57 class Pair { // OVERVIEW: un tipo record int coeff; int exp; // costruttore Pair (int c, int n) // EFFECTS: inizializza il “record” con i // valori di c ed n { coeff = c; exp = n;} } Notate che le variabili d’istanza sono pubbliche (non c’e’ astrazione) Un esempio

58 Un ‘altra rappresentazione di Poly public class Poly { // OVERVIEW: un Poly è un polinomio a // cofficienti interi non modificabile // esempio: c 0 + c 1 *x + c 2 *x private Vector termini; // la rappresentazione private int deg; // la rappresentazione  gli oggetti contenuti in termini sono Pair che rappresentano i termini con coefficiente diverso da 0 4 Non possiamo definire un Vector di Pair (lo vedremo in seguito)

59 Sommario 4 Abbiamo realizzato tipi di dato astratto usando l’astrazione fornita dalla specifica 4 La specifica e l’implementazione stanno nella stessa classe 4 la specifica funge da interfaccia con chi usa il tipo di dato, puo’ anche essere compilata senza avere l’implementazione insieme ai moduli che la usano 4 Specifica ed implementazione sono di conseguenza legate da un concetto di correttezza (che vedremo)

60 Cos’e un interfaccia? 4 E’ una classe che non contiene implementazione, ma solo gli headers dei metodi (niente costruttori) 4 E’ utile per definire implementazioni multiple di un tipo di dato astratto come sottoclassi dell’interfaccia (si dice che implementano l’interfaccia)

61 Perche’ non abbiamo usato interfacce? 4 Varie implementazioni sono sottotipi dell’interfaccia 4 Avremmo specifica nel supertipo e l’implementazione nel sottotipo 4 Piu’ difficile ragionare sul legame tra specifica ed implementazione (il sottotipo potrebbe aggiungere metodi, cambiare la specifica…) 4 Vedremo comunque il problema delle relazioni tra tipo e sottotipo a livello di specifiche, e quindi l’uso delle interfacce piu’ avanti

62 Esempio di una operazione public int coeff (int d) // EFFECTS: ritorna il coefficiente del // termine in this che ha come esponente d {for (int i = 0; i < termini.size(); i++) {Pair p = (Pair) termini.get(i); if (p.exp == d) return p.coeff;} return 0;} 4 notare il casting necessario perche’ get ritorna un oggetto con tipo apparente Object 4 Accediamo direttamente al campo exp del tipo record Pair

63 Metodi addizionali 4 esistono vari metodi –definiti nella classe Object che possono essere ereditati o ridefiniti da qualunque classe 4 Devono essere ridefiniti quando –L’implementazione di default non è corretta per la sottoclasse o è poco informativa

64 equals  in Object verifica se due oggetti sono lo stesso oggetto –non se i due oggetti hanno lo stesso stato –va bene per i tipi modificabili (può essere ereditata, Intset) dove lo stato è variabile –dovrebbe essere ridefinita per i tipi non modificabili (Poly) in termini di uguaglianza fra gli stati

65 equals 4 Nei tipi modificabili –Due oggetti che hanno lo stesso stato (ma non coincidono) possono comunque essere distinti Quando ne cambiamo il valore –Quindi due oggetti che hanno lo stesso stato non sono equivalenti

66 clone  in Object genera una copia dell’oggetto –nuovo oggetto con lo stesso stato copiando il frame delle variabili istanza 4 questa implementazione non è sempre corretta –per esempio, in IntSet i campi els dei due oggetti conterrebbero esattamente lo stesso Vector creando una situazione di condivisione (con trasmissione di modifiche) non desiderata  il metodo viene ereditato solo se l’header della classe contiene la clausola implements Cloneable 4 se non va bene quella di default si deve reimplementare

67 toString  in Object genera una stringa contenente il tipo dell’oggetto ed il suo Hash code 4 normalmente si vorrebbe ottenere una stringa composta da –tipo –valori dello stato 4 se se ne ha bisogno, va ridefinita sempre

68 Esempi da provare 4 specifica dei tipi utilizzati nello stato della semantica operazionale –Frame e Stacks modificabili –gli altri non modificabili –si supponga che gli identificatori, le liste di parametri ed il codice siano stringhe –si usino eccezioni per trattare i casi particolari