Astrazione procedurale ed Eccezioni 1 Procedure stand alone

Astrazione procedurale ed Eccezioni 1

Procedure stand alone 4 indipendenti da specifici oggetti 4 come si realizzano in Java – metodi statici definiti dentro una classe che non ha • variabili e metodi di istanza • costruttore – può contenere variabili statiche • condivise dalle varie attivazioni di metodi 4 una procedura è un mapping da un insieme di argomenti di ingresso ad un insieme di risultati – con possibile modifica di alcuni degli argomenti di ingresso • solo se sono oggetti – possibili effetti laterali su variabili di classe visibili 2

Astrazione via specifica 4 la specifica descrive le proprieta’ della procedura, astraendo dal modo in cui la procedura ottiene il risultato atteso, ovvero dall’implementazione 4 la specifica e’ l’interfaccia verso chi usa la procedura e contiene tutte e sole le informazioni necessarie a chi la usa 4 l’implementazione è in questo modo invisibile all’utente 3

Importanza della specifica 4 località – l’implementazione di una procedura può essere letta o scritta senza esaminare le implementazioni delle altre procedure • utile durante lo sviluppo (anche da parte di più persone) e la manutenzione 4 modificabilità – una procedura può essere reimplementata senza richiedere modifiche alle astrazioni che la utilizzano • utile durante la manutenzione per ridurre gli effetti indotti da una modifica 4

Come e’ fatta la specifica? 4 1. 2. “scheletro” formato da headers dei metodi pubblici commenti informali (tipo quelli che abbiamo usato a LIP) che descrivono le proprieta’ dei metodi, ovvero la relazione tra gli inputs ed i risultati (gli input sono i parametri ma anche quelli impliciti se ci sono modifiche esterne) 4 manca il codice del corpo dei metodi (implementazione) • che può essere sviluppato in un momento successivo ed indipendentemente dallo sviluppo dei “moduli” che usano le procedure specificate 5

Un esempio di specifica public class Arrays { // OVERVIEW: La classe fornisce un insieme di // procedure utili per manipolare arrays di int public static int search (int[] a, int x) // EFFECTS: se x occorre in a, ritorna un // indice in cui occorre, altrimenti -1 public static int search. Sorted (int[] a, int x) // REQUIRES: a è ordinata in modo crescente // EFFECTS: se x occorre in a, ritorna un // indice in cui occorre, altrimenti -1 public static void sort (int[] a) // MODIFIES: a // EFFECTS: riordina gli elementi di a in // modo crescente, per esempio // se a=[3, 1, 6, 1] a_post=[1, 1, 3, 6] } 6

La classe public class Arrays { // OVERVIEW: La classe fornisce un insieme di // procedure utili per manipolare arrays di int. . } 4 la classe compare nella specifica, perché i metodi dovranno essere reperiti usando il nome della classe 4 OVERVIEW: si usa per descrivere in modo informale il contenuto della classe 7

I metodi. . . public static int search (int[] a, int x). . . public static int search. Sorted (int[] a, int x). . . public static void sort (int[] a). . . 4 gli headers dei metodi (codice Java) sono la parte sintattica della specifica del metodo 4 specificano (in aggiunta alla visibilità) – – nome del metodo nomi e tipi dei parametri formali tipo del risultato search: int array * int -> int 8

Inoltre I metodi sono anche corredati da commenti informali (tipo quelli usati a LIP) che descrivono la (1) precondizione (2) postcondizione (3) eventuali modifiche 9

I commenti: precondizioni. . . public static int search (int[] a, int x) // EFFECTS: se x occorre in a, ritorna un // indice in cui occorre, altrimenti -1 public static int search. Sorted (int[] a, int x) // REQUIRES: a è ordinata in modo crescente // EFFECTS: se x occorre in a, ritorna un // indice in cui occorre, altrimenti -1. . . 4 la clausola REQUIRES descrive le precondizioni che devono essere verificate sui parametri di ingresso perché la procedura sia definita – possono esserci inputs impliciti (variabili visibili, files, etc. ) 4 se la clausola REQUIRES non è presente, la procedura è totale (esempio, search) – è definita per tutti gli inputs corretti rispetto al tipo 4 altrimenti è parziale (esempio, search. Sorted) 10

I commenti: MODIFIES. . . public static void sort (int[] a) // MODIFIES: a // EFFECTS: riordina gli elementi di a in // modo crescente, per esempio // se a=[3, 1, 6, 1] a_post=[1, 1, 3, 6]. . . 4 la clausola MODIFIES elenca tutti i parametri di ingresso che vengono modificati – compresi gli inputs impliciti (variabili visibili, files, etc. ) 4 se esistono parametri di ingresso che vengono modificati – la procedura produce effetti laterali 4 Se MODIFIES non e’ presente allora vuol dire che non viene modificato niente 11

I commenti: postcondizioni. . . public static int search. Sorted (int[] a, int x) // REQUIRES: a è ordinata in modo crescente // EFFECTS: se x occorre in a, ritorna un // indice in cui occorre, altrimenti -1 public static void sort (int[] a) // MODIFIES: a // EFFECTS: riordina gli elementi di a in // modo crescente, per esempio // se a=[3, 1, 6, 1] a_post=[1, 1, 3, 6]. . . 4 la clausola EFFECTS descrive le proprietà degli outputs e le modifiche effettuate su tutti gli inputs elencati nella clausola MODIFIES 4 assumendo che siano verificate le proprietà specificate in REQUIRES 4 a_post rappresenta il valore di a dopo il ritorno del metodo 12

Procedure Parziali. . . public static int search. Sorted (int[] a, int x) // REQUIRES: a è ordinata in modo crescente // EFFECTS: se x occorre in a, ritorna un // indice in cui occorre, altrimenti -1. . . 4 La specifica dice che: 4 se search. Sorted e’ chiamata con valori che soddisfano la precondizione (REQUIRES) allora valgono le proprieta’ specificate dalla postcondizione (EFFECTS) 4 non dice niente su cosa succede quando search. Sorted e’ chiamata con un array non ordinato 13

Specifica ed implementazione 4 L’implementazione e’ data dal – codice dei corpi dei metodi 4 Puo’ essere sviluppata in un momento successivo ed indipendentemente dallo sviluppo dei moduli che usano le procedure specificate (questi moduli vedono solo la loro specifica) 4 Chiaramente l’implementazione dipende dalla specifica, nel senso che la deve soddisfare 14

Cosa vuol dire? 4 La procedura modifica solo gli inputs indicati nella clausola MODIFIES 4 Se la procedura è chiamata con parametri che soddisfano REQUIRES allora produce dei risultati che soddisfano EFFECTS 4 Se la specifica è parziale non ci sono vincoli su quello che può fare quando è chiamata con parametri che non soddisfano EFFECTS (run forever, ……) 15

Esempi di implementazione 1 public class Arrays { // OVERVIEW: La classe fornisce un insieme di // procedure utili per manipolare arrays di int. . . public static int search. Sorted (int[] a, int x) // REQUIRES: a è ordinata in modo crescente // EFFECTS: se x occorre in a, ritorna un // indice in cui occorre, altrimenti -1 // usa la ricerca lineare {if (a == null) return -1; for (int i = 0; i < a. length; i++) if (a[i] == x) return i; else if (a[i] > x) return -1; }. . . } 4 se la precondizione non è soddisfatta, l’implementazione non è corretta (si interrompe la ricerca. . ) 4 implementazione piu’ efficiente sfruttando la precondizione 16

Esempi di implementazione 1 public class Arrays { // OVERVIEW: La classe fornisce un insieme di // procedure utili per manipolare arrays di int. . . public static int search. Sorted (int[] a, int x) // REQUIRES: a è ordinata in modo crescente // EFFECTS: se x occorre in a, ritorna un // indice in cui occorre, altrimenti -1 // usa la ricerca lineare {if (a == null) return -1; for (int i = 0; i < a. length; i++) if (a[i] == x) return i; else if (a[i] > x) return -1; }. . . } 4 la specifica comunque soddisfatta 4 E’ corretto ritornare -1 se a e’ null, l’elemento non occorre nell’array 17

Esempi di implementazione 2. 1 public class Arrays { // OVERVIEW: . . . public static void sort (int[] a) // MODIFIES: a // EFFECTS: riordina gli elementi di a in modo // crescente, se a=[3, 1, 6, 1] a_post=[1, 1, 3, 6] // usa il Quick. Sort {if (a == null) return; quick. Sort(a, 0, a. length - 1); }. . . } 4 Inseriamo nella classe il metodo privato quick. Sort – Non fa parte della specifica (non e’ visibile fuori dalla classe) 4 per i metodi private e’ sufficiente l’implementazione – Diamo anche I commenti, utili per la correttezza 4 Avremmo potuto usare un qualsiasi altro algoritmo di ordinamento (questo resta invisibile a chi usa la procedura sort) 18

Procedure parziali o totali? 4 Le procedure parziali sono meno sicure – Quando chiamate con parametri che non soddisfano la clausola REQUIRES possono produrre errori di qualsiasi tipo (la specifica non ci fornisce informazioni) – Chi chiama una procedura parziale dovrebbe fornire parametri che soddisfano REQUIRES (ma come garantirlo senza sapere dove viene usata? ) – D’altra parte le procedure parziali sono in genere più efficienti (vedi search. Sorted) 19

Precondizione non soddisfatta 4 non è verificata la precondizione – potrebbe succedere di tutto, dal ritorno di risultati privi di significato, alla non terminazione, al danneggiamento di dati permanenti public static int mcd (int n, int d) // REQUIRES: n, d > 0 // EFFECTS: ritorna il massimo comun divisore // di n e d 4 chiunque utilizzi la procedura deve preoccuparsi di verificare che i dati passati verifichino la precondizione – chi lo garantisce? 4 chi implementa la procedura può ignorare i casi non previsti 20

Parziale o totale? 4 Se la procedura parziale è usata in un contesto limitato allora è facile verificarne l’uso (vedi quick. Sort che puo’ essere chiamata solo nella classe Arrays) 4 Altrimenti, è conveniente modificare la specifica e l’implementazione in modo che la procedura segnali in modo esplicito l’errore, effettuando un controllo esplicito sui parametri di ingresso che ritorna un risultato particolare 21

Esempio public static int fact (int n) //REQUIRES: n>0 // EFFECTS: ritorna n! public static int fact (int n) // EFFECTS: se n>0, ritorna n!, altrimenti 0 4 La prima versione e’ parziale 4 La seconda e’ totale, usiamo un valore particolare 0 per segnalare una situazione particolare. 22

Altro Esempio public static int search (int[] a, int x) // EFFECTS: se x occorre in a, ritorna un // indice in cui occorre, altrimenti -1 4 La procedura e’ totale (si usa un valore particolare per segnalare un caso speciale) 4 il chiamante deve comunque trattare in modo speciale il valore che codifica la situazione particolare – chi lo garantisce? 23

Robustezza 4 le procedure parziali e la codifica di situazioni particolari portano a programmi poco robusti 4 un programma robusto si comporta in modo ragionevole anche in presenza di “errori” – per esempio, continua dopo il verificarsi dell’errore con un comportamento ben-definito che approssima quello normale – come minimo, termina con un messaggio di errore “informativo” senza danneggiare dati permanenti 4 cosa serve? – un meccanismo (o approccio) che trasferisca l’informazione al chiamante in tutte queste situazioni – distinguendo le varie situazioni – con una gestione delle situazioni “strane” separata dal flusso di controllo normale della procedura 24

Il meccanismo delle eccezioni 4 una procedura può terminare – normalmente, ritornando un risultato – in modo eccezionale • ci possono essere diverse terminazioni eccezionali • in Java, corrispondono a diversi tipi di eccezioni • il nome del tipo di eccezione viene scelto da chi specifica la procedura per fornire informazione sulla natura del problema 4 Esistono eccezioni predefinite 4 Ma si possono anche definire nuove eccezioni per segnalare situazioni particolari 25

Le eccezioni in Java 4 i tipi di eccezione sono particolari classi che – contengono solo il costruttore • ci possono essere più costruttori overloaded – sono definite in “moduli” separati da quelli che contengono i metodi che le possono sollevare 4 le eccezioni sono oggetti – creati eseguendo new di un exception type • e quindi eseguendo il relativo costruttore 4 esiste una gerarchia “predefinita” di tipi relativi alle eccezioni – nuovi tipi di eccezioni sono collocati nella gerarchia con l’usuale extends 26

La gerarchia di tipi per le eccezioni Throwable Error Exception Runtime. Exception 4 se un nuovo tipo di eccezione estende la classe Exception – l’eccezione è checked 4 se un nuovo tipo di eccezione estende la classe Runtime. Exception – l’eccezione è unchecked 27

Differenza: checked e unchecked 4 se una procedura può sollevare una eccezione checked (controllata) – deve elencarla nel suo header (tramite throws) • altrimenti si verifica un errore a tempo di compilazione 4 se una procedura può sollevare una eccezione unchecked (runt-time) – può non elencarla nel suo header 28

Sintassi della clausola throws <modificatori> <tipo> <nome-metodo> (<listaparametri>) throws <Classe-ecc 1>, . . . , <Classeecc. N> { <corpo-metodo> } 4 La clausola throws viene inserita nella dichiarazione del metodo per informare il compilatore che durante l'esecuzione di quel metodo possono essere generate eccezioni dei tipi elencati dopo la parola chiave throws, la cui gestione viene delegata al chiamante. 4 Notate che in questo modo le eccezioni fanno anche parte della specifica (chi usa la procedura deve esserne informato!) 4 Quelle checked devono essere obbligatoriamente riportate nell’header 4 Suggerimento: elencare anche quelle unchecked in modo da renderle parte della specifica 29

Eccezioni Primitive – Index. Out. Of. Bounds. Exception E’ una eccezione unchecked, indica l’accesso ad un posizione inesistente di un array – Null. Pointer. Exception E’ una eccezione unchecked, indica l’accesso ad un oggetto indefinito 30

Definire tipi di eccezione public class Nuovo. Tipo. Di. Ecc extends Exception { public Nuovo. Tipo. Di. Ecc(String s) {super(s); } } 4 è checked 4 definisce solo un costruttore – come sempre invocato quando si crea una istanza con la new – il costruttore può avere parametri 4 il corpo del costruttore riutilizza semplicemente il costruttore del supertipo – perché deve passargli il parametro 4 una new di questa classe provoca la creazione di un nuovo oggetto che “contiene” la stringa passata come parametro 31

Costruire oggetti eccezione public class Nuovo. Tipo. Di. Ecc extends Exception { public Nuovo. Tipo. Di. Ecc(String s) {super(s); } } 4 una new di questa classe provoca la creazione di un nuovo oggetto che “contiene” la stringa passata come parametro Exception e = new Nuovo. Tipo. Di. Ecc (“Questa è la ragione”) ; String s = e. to. String() ; 4 la variabile s punta alla stringa “Nuovo. Tipo. Di. Ecc: Questa è la ragione” 32

Lanciare eccezioni 4 una procedura può terminare – (ritorno normale) con un return – (ritorno di una eccezione) con un throw public static int fact (int n) throws Nonpositive. Exc // EFFECTS: se n>0, ritorna n! // altrimenti solleva Nonpositive. Exc { if (n <= 0) throw new Non. Positive. Exc(“Num. fact”); . . . } 4 la stringa descrive la procedura che la ha sollevata 4 può comparire nel messaggio di errore che si stampa subito prima di forzare la terminazione dell’esecuzione 4 Notate che il comportamento eccezionale va incluso nella specifica 33

Gestione delle Eccezioni 4 Cosa succede quando un metodo termina sollevando un’eccezione? 4 L’eccezione viene passata al metodo chiamante 4 Per default, un metodo che riceve un'eccezione termina a sua volta l'esecuzione e passa l'eccezione al metodo chiamante. 4 Quando l'eccezione raggiunge main, l'esecuzione del programma termina stampando un opportuno messaggio di 34 errore.

Esempio: riferimento null public class Nested. Null. Pointer { public static void bar(){ Object o = null; System. out. println(o. to. String()); } public static void foo(){ bar(); } public static void main(String [] args){ foo(); } } 35

Esecuzione del main Ø Ø java Nested. Null. Pointer. Exception in thread "main" java. lang. Null. Pointer. Exception at Nested. Null. Pointer. bar(Nested. Null. Pointer. java: 4) at Nested. Null. Pointer. foo(Nested. Null. Pointer. java: 7) at Nested. Null. Pointer. main(Nested. Null. Pointer. java: 10) 4 Tutti i metodi annidati terminano 4 Viene elencata la catena dei metodi attivi nel momento in cui si verifica l'eccezione (bar - foo - main) e per ogni metodo la linea di codice dove si è verificata. 36

Esempio: Outof Bounds public class Out. Of. Bounds { public static void main(String [] args){ int [] array = new int [5]; for (int i = 0; i < array. length; i++) { array[i] = (int) (100 * Math. random()); } System. out. println("Contenuto dell'array: "); // Errore nella guardia del for (int i = 0; i <= array. length; i++) { System. out. println(array[i]); } } } 37

Alternativa: Gestione Esplicita Il chiamante puo’ (1) gestione di default, mediante propagazione dell’eccezione alla procedura chiamante • possibile solo per eccezioni non checked o per eccezioni checked elencate nell’header della procedura che riceve l’eccezione (2) Puo’ catturare e gestire l’eccezione: gestione esplicita (mediante try and catch) 38

Catturare una Eccezione 4 Il codice che potrebbe sollevare l’eccezione e’ racchiuso all’interno di uno statement try 4 Il codice per gestire l’eccezione e’ racchiuso all’interno di uno statement catch 39

Sintassi: forma semplificata try { <istruzioni-try>; // possono lanciare delle eccezioni } catch(<sottoclasse-Throwable> e 1) {; // catturiamo l'eccezione e 1 di tipo <sottoclasse-Throwable> <istruzioni-catch>; // gestiamo e 1 } 40

Semantica Si eseguono le <istruzioni-try>. • Se l'esecuzione termina senza fallimenti si prosegue ad eseguire la prima istruzione successiva al blocco try-catch. • Altrimenti, se l'esecuzione di <istruzioni-try> lancia un'eccezione except che e’ sottotipo di <sottoclasse-Throwable> si eseguono le <istruzioni-catch>. Infine si prosegue ad eseguire la prima istruzione successiva al blocco try-catch. • Altrimenti, se l’eccezione non e’ sottotipo di <sottoclasse-Throwable> il metodo si comporta come se non ci fosse try-catch 41

Esempio: termina normalmente public class Catch. Out. Of. Bounds { public static void main(String [] args) { int [] array = new int [5]; try { int i = 0; while (true) // ciclo infinito // ben presto i oltrepassera' il limite dell'array System. out. println(array[i++]); } catch (Array. Index. Out. Of. Bounds. Exception e) { System. out. println(”Finito"); } } } • L’eccezione e’ catturata il metodo termina normalmente • Pessimo modo di fare un ciclo su un array 42

Gestione esplicita delle eccezioni 4 codice per gestire l’eccezione Non. Positive. Exc eventualmente sollevata da una chiamata di fact try { x = Num. fact (y); } catch (Non. Positive. Exc e) { // qui possiamo usare e, cioè l’oggetto eccezione String s = e. to. String() ; System. out. println(s) } 4 Nel catch e’ contenuto il codice per gestire l’eccezione 4 Il programma termina normalmente scrivendo il contenuto dell’eccezione (una spiegazione di cosa e’ successo) 43

Gestione esplicita delle eccezioni 4 la clausola catch non deve necessariamente identificare il tipo preciso dell’eccezione, ma basta un suo supertipo, principio di sostituzione try { x = Arrays. search. Sorted (v, y); } catch (Exception e) { s. Println(e); return; } // s è una Print. Writer 4 segnala l’informazione sia su Null. Pointer. Exc che su Not. Found. Exc, eccezioni sollevate da searchsorted (vedi dopo) 44

Try e Catch annidati try {. . . ; try { x = Arrays. search. Sorted (v, y); } catch (Null. Pointer. Exc e) { throw new Not. Found. Exc (); } } catch (Not. Found. Exc b ) {. . . } 4 la clausola catch nel try più esterno cattura l’eccezione Not. Found. Exc se è sollevata da search. Sorted o dalla clausola catch più interna 4 l’eccezione Null. Pointer. Exc non è visibile da fuori 45

Eccezioni e specifica 4 le eccezioni giocano un ruolo molto importante nell’astrazione via specifica – la specifica del comportamento deve riguardare anche le terminazioni eccezionali e descrivere esattamente cosa succede quando una procedura solleva una eccezione – Il chiamante della procedura deve essere informato tramite la specifica del significato delle eccezioni sollevate in modo da poterle eventualmente gestire 46

Dimenticare una eccezione public static int search. Sorted (int[] a, int x) throws Null. Pointer. Exc // REQUIRES: a è ordinata in modo crescente // EFFECTS: se x occorre in a, ritorna un // indice in cui occorre, altrimenti -1 { for (int i = 0; i < a. length; i++) if (a[i] == x) return i; else if (a[i] > x) return -1; }. . . } 4 Abbiamo tolto il controllo se a e’ null (ritornava -1) 4 quindi viene sollevata l’eccezione Null. Pointer. Exc (unchecked) 4 Non soddisfa la specifica, la procedura puo’ terminare senza soddisfare la postcondizione (che non prevede l’eccezione) 47

Ruolo delle eccezioni 4 le eccezioni non sono necessariamente errori – ma metodi per richiamare l’attenzione del chiamante su situazioni particolari (classificate dal progettista come eccezionali) 4 possono essere utilizzate per ridurre al minimo i vincoli della clausola REQUIRES nella specifica, ovvero per segnalare le condizioni sui parametri (parziali vs totale) 4 la precondizione dovrebbe restare solo se • la condizione è troppo complessa da verificare (vedi search. Sorted) • il contesto d’uso limitato del metodo (private) ci permette di convincerci che tutte le chiamate della procedura la soddisfano 48

Modifica del Fattoriale public static int fact (int n) throws Nonpositive. Exc // EFFECTS: se n>0, ritorna n! // altrimenti solleva Nonpositive. Exc 4 La clausola EFFECTS descrive il comportamento della procedura includendo tutti i casi anche quelli per cui viene sollevata l’eccezione (quelli negativi) – La procedura fact è totale (non abbiamo vincoli in REQUIRES) – Soluzione migliore di quella in cui ritornavamo un valore particolare, chi la usa deve gestire l’eccezione 49

Eccezioni nella specifica public static int search. Sorted (int[] a, int x) throws Null. Pointer. Exc, Not. Found. Exc // REQUIRES: a è ordinato in modo crescente // EFFECTS: se a è null solleva Null. Pointer. Exc // se x non occorre in a solleva Not. Foundexc // altrimenti ritorna un indice in cui occorre 4 le procedure possono continuare ad essere parziali – Verificare la precondizione e sollevare un’eccezione ridurrebbe in modo inaccettabile l’efficienza di search. Sorted – Le eccezioni sono comunque utili per segnalare altre situazioni (tipicamente per controllare che i parametri non siano null) 50

Defensive programming 4 l’uso delle eccezioni facilita uno stile di progettazione e programmazione che protegge rispetto agli errori – anche se non sempre un’eccezione segnala un errore 4 fornisce una metodologia che permette di riportare situazioni di errore in modo ordinato – senza disperdere tale compito nel codice che implementa l’algoritmo 4 nella programmazione defensive, si incoraggia il programmatore a verificare l’assenza di errori ogniqualvolta ciò sia possibile – ed a riportarli usando il meccanismo delle eccezioni – un caso importante legato alle procedure parziali 51

Quando una procedura non soddisfa la sua precondizione 4 con le eccezioni le procedure tendono a diventare totali – ma non è sempre possibile 4 chiama la procedura dovrebbe farsi carico di effettuare tale controllo – sollevando una eccezione unchecked • non elencata nell’header e non considerata negli EFFECTS, perché si riferisce ad un caso che non soddisfa REQUIRES • questa eccezione può essere catturata, magari ad un livello superiore – si suggerisce di usare in questi casi una eccezione generica unchecked Failure. Exception 52