LIP: 2 Maggio 2008 Classi Astratte

Cos’e’ una Classe Astratta una classe astratta e’ un particolare tipo di classe permette di fornire una implementazione parziale di un tipo di dato astratto

Cos’e’ una Classe Astratta definisce metodi astratti (non implementati) definisce metodi concreti (implementati eventualmente usando anche i metodi astratti) ammette la dichiarazione di variabili ammette costruttori

Cos’e’ una Classe Astratta Non e’ possibile creare oggetti istanza di una classe astratta Di conseguenza i costruttori possono essere chiamati solo dalle sottoclassi per inizializzare le variabili ereditate

Sottotipi L’implementazione e’ completata dai sottotipi, che: estendono la definizione dello stato aggiungendo nuove variabili definiscono i relativi costruttori implementano i metodi ereditati astratti eventualmente sovrascrivono quelli concreti

A cosa servono? per fattorizzare la parte comune a vari sottotipi per esempio, per definire implementazioni multiple di un tipo di dato astratto (analogo interfacce)

Perche’ non un’interfaccia? Una classe astratta e’ utile i sottotipi hanno delle parti comuni Quelle che possono essere implementate nel supertipo

Esempio La specifica di un tipo di dato astratto puo’ essere definita da un’ interfaccia I sottotipi definiscono diverse implementazioni del tipo di dato Esempio: stack di interi

public interface Stack { \\ OVERVIEW: uno Stack e’ una collezione di \\elementi (interi) organizzati per ordine di inserimento con una politica \\ LIFO. E’ modificabile \\metodi astratti public int size(); \\ EFFECTS: restituisce il numero di elementi di this public int top() throws EmptyException; \\ EFFECTS: se this e’ vuoto solleva EmptyException, altrimenti \\ritorna l’ultimo elemento inserito public void pop() throws EmptyException; \\ MODIFIES: this \\ EFFECTS: se this non e’ vuoto rimuove l’ultimo elemento inserito, \\altrimenti solleva EmptyException

public void push(int o); \\ MODIFIES: this \\ EFFECTS: inserisce o nella pila public String toString(); \\ EFFECTS: restituisce una stringa che contiene gli elementi di this \\ nell’ordine che hanno public void somma(Stack p) throws InvalidSizeException; \\ MODIFIES: this \\EFFECTS: se p e’ null solleva NullPointerException, se \\ this e p non hanno lo stesso numero di elementi \\ solleva InvalidSizeException, altrimenti \\ modifica this, sommando l’elemento di p nella posizione \\ corrispondente public void svuotapila(); \\ MODIFIES: this \\EFFECTS: elimina tutti gli elementi }

Supertipo: interfaccia Non contiene implementazione I sottotipi devono fornire tutta l’implementazione: ListStack ====> implementato con una lista concatenata VectorStack ====> implementato con un Vector Le differenze di implementazione restano invisibili al codice scritto per il supertipo Stack

Codice scritto per il supertipo (interfaccia) public static boolean cerca(Stack p, int x) { \\ REQUIRES: p non null \\EFFECTS: restituisce true se x occorre in this, \\false altrimenti if (p.size()==0) {return false;} int top=p.top(); if (x==top) {return true;} p.pop(); boolean result=cerca(p,x); p.push(top); return result; }

Astrazione tramite la specifica Si forza ad astrarre tramite la specifica Il codice di cerca e’ scritto in base al supertipo (i sottotipi che sono l’impolementazione sono mascherati) Il metodo funziona per tutti i sottotipi (tutte le implementazioni) Usando l’interfaccia Stack i moduli che usano il tipo di dato astratto possono anche essere compilati

Supertipo: classe astratta E’ possibile implementare una parte nel supertipo in modo analogo per i due sottotipi? I metodi pop, top,push,toString devono essere astratti (dipendono dal modo in cui si implementa) I metodi size,svuotapila,somma al contrario non dipendono dalla rappresentazione della pila, possono essere implementati nel supertipo

Metodi concreti size si puo’ implementare utilizzando una variabile d’istanza ( protected) che memorizza il numero di elementi Le variabili d’istanza di una classe astratta non ha molto senso mascherarle in quanto i sottotipi devono completare l’implementazione (tipicamente dipendono dall’implementazione della superclasse) svuotapila,somma si possono implementare utilizzando i metodi astratti pop(), push() e top()

public abstract class Stack { \\ OVERVIEW: uno Stack e’ una collezione di \\elementi (interi) organizzati per ordine di inserimento con una politica \\ LIFO. E’ modificabile protected int sz; public Stack(){\\ EFFECTS: inizializza this allo Stack vuoto sz=0;} \\metodi astratti (specifica uguale) public abstract int top() throws EmptyException; public abstract void pop() throws EmptyException; public abstract void push(int o); public abstract String toString();

\\metodi concreti public int size(){ \\ EFFECTS: restituisce il numero di elementi di this return sz;} public void svuotapila(){ \\ MODIFIES: this \\EFFECTS: elimina tutti gli elementi while (size()==0) pop();}

public void somma(Stack p) throws InvalidSizeException{ \\ MODIFIES: this \\EFFECTS: se p e’ null solleva NullPointerException, se \\ this e p non hanno lo stesso numero di elementi \\ solleva InvalidSizeException, altrimenti \\ modifica this, sommando l’elemento di p nella posizione \\ corrispondente if (p==null) throw new NullPointerException(“Stack.somma”); if (size() != p.size()) throw new InvalidSizeException(“Stack.somma”); if (size() > 0) { int newtop1=p.top(); int newtop2=top(); pop(); somma(p.pop()); push(newtop1+newtop2); p.push(newtop1); }} }

Parte II Definiamo un sottotipo di Stack, VectorStack Definisce un’implementazione completa della pila di interi tramite Vector Completa l’implementazione della classe astratta

public class VectorStack extends Stack { \\ OVERVIEW: e’ un sottotipo di Stack private Vector pila; public VectorStack(){ \\ EFFECTS: inizializza this allo Stack vuoto super(); pila=new Vector();} \\metodi concreti (specifica uguale) public int top() throws EmptyException{ if (sz==0) throw new EmptyException(“Stack.top”); return ((Integer) pila.elementAt(pila.size()-1)).intValue();} public void pop() throws EmptyException{ if (sz==0) throw new EmptyException(“Stack.top”); pila.removeelementAt(pila.size()-1); sz--;}

public void push(int o){ pila.addElement(new Integer(o)); sz++;} public String toString(){ String result=“”; for (int i=0;i < pila.size();i++) {result=result + (Integer) pila.elementAt(i).intValue();} return result; }

Esercizio Abbiamo visto la definizione di tipi di dato astratti Insieme di interi Insieme ordinato di interi Vogliamo usare la gerarchia di tipi per fattorizzare le informazioni comuni ai sottotipi

Classe astratta Contiene la parte comune dell’implementazione cardinalita’ la struttura dati usata per l’implementazione Restano astratti i metodi che modificano la struttura dati (che differiscono nei due casi) Analogamente il metodo di ricerca

Supertipo public abstract class IntSet { // OVERVIEW: un IntSet è un insieme modificabile // di interi di dimensione qualunque // costruttore public IntSet () { // EFFECTS: inizializza this all’insieme vuoto} //metodi astratti public abstract void insert(int x); // MODIFIES: this // EFFECTS: aggiunge x a this public abstract void remove (int x); // MODIFIES: this // EFFECTS: toglie x da this public abstract boolean isIn (int x); // EFFECTS: se x appartiene a this ritorna // true, altrimenti false

Supertipo //metodi concreti public boolean subset (IntSet x) { // EFFECTS: se this e’ sottoinsieme di x restituisce // true, altrimenti false} public void union(IntSet x) { //MODIFIES: this // EFFECTS:modifica this facendo l’unione con x} public void intersection(IntSet x) { //MODIFIES: this // EFFECTS:modifica this facendo l’intersezione con x} public int size(){ // EFFECTS:restituisce la cardinalita’ di this} }

Esercizi Esercizio I: implementare la classe astratta Esercizio II: definire un sottotipo SortedIntSet definisce insiemi ordinati implementa in modo opportuno i metodi astratti estende la superclasse con un metodo subset (overloaded) prende come parametro un SortedIntSet (da implementare in modo piu’ efficiente)