Metodo I metodi sono uno strumento che i

Metodo I metodi sono uno strumento che i programmatori usano per strutturare i programmi, sia per renderli più facili da capire che permettere il riutilizzo del codice. Essi consentono al programmatore di concentrarsi su una parte del problema. I parametri del sottoprogramma rappresentano i dati che il metodo usa per svolgere il compito assegnato. Vantaggi dell’uso di metodi: n. Possibilità di modularizzare i programmi, rendendoli più leggibili; n. Riusabilità del Software: possibilità di riutilizzare porzioni di codice in punti diversi del programma o in programmi diversi (evita la duplicazione del codice). 1

Metodi Un metodo è una sequenza di istruzioni che vengono attivate a seguito di una chiamata. Lo scambio di informazioni fra metodo invocato e metodo chiamante avviene attraverso il passaggio di zero o più parametri in ingresso e un (eventuale) valore restituito in uscita. Parametri in ingresso sottoprogramma Valore restituito Parametri in ingresso l Parametri formali (specificati nella definizione del metodo stesso): simboli che rappresentano i dati su cui il metodo opera l Parametri attuali (specificati nella chiamata del metodo): dati corrispondenti ai parametri formali, su cui il metodo effettivamente opera In Java i sottoprogrammi si chiamano metodi e sono definiti sempre all’interno di una classe. 2

Definizione di metodi w. La dichiarazione di un metodo specifica le istruzioni che verranno eseguite quando il metodo è invocato (chiamato). w. Quando viene invocato un metodo, il flusso di controllo passa al metodo ed vengono eseguite le istruzioni definite nel metodo. w. Quando l’esecuzione del metodo termina, il flusso di controllo ritorna al punto in cui era stato chiamato il metodo e l’esecuzione continua dall’istruzione successiva alla chiamata. w. La chiamata può restituire un valore o no, in dipendenza da come e’ stato definito il metodo. 3

Flusso di controllo di un metodo Quando si incontra la chiamata di un metodo il controllo viene trasferito alla prima istruzione del metodo stesso. Il flusso di esecuzione torna al codice chiamante quando si incontra una istruzione return (che restituisce il valore specificato) oppure al termine del codice del metodo per metodi definiti void. Il metodo chiamato può essere definito nella stessa classe, nel qual caso per chiamarlo e’ sufficiente il nome del metodo. compute my. Method(); 4

Passaggio di parametri Ogni volta che un metodo viene chiamato, i parametri attuali usati nella chiamata vengono copiati nei parametri formali. 1. 2. 3. 4. int int val 1 = 100; val 2 = 20; div = 3; ris = calc(val 1, val 2, div); 1. static int calc(int num 1, int num 2, int div) { 2. int val = (num 1 + num 2)/div; 3. return val; 4. } 5

Metodi 1. public class Esempio { 2. static int calc(int num 1, int num 2, int div) { 3. int val = (num 1 + num 2)/div; 4. return val; 5. } 6. static public void main(String[] args) { 7. int val 1 = 100; 8. int val 2 = 20; 9. int ris = 0; 10. if(args. length > 0){ 11. int div = Integer. parse. Int(args[0]); 12. ris = calc(val 1, val 2, div); 13. System. out. println(ris); 14. } 15. } 16. } 6

Eccezioni Durante l’esecuzione di un programma possono verificarsi degli errori dovuti a: dati errati in ingresso o errori di programmazione. Un buon programma deve prevedere la gestione dei fallimenti individuando e ripristinando l’errore. Spesso il punto del programma in cui l’errore si manifesta non coincide con il punto in cui è possibile ripristinarlo. 7

Eccezioni Un’eccezione è un oggetto che descrive una situazione inusuale o erronea. Le eccezioni vengono lanciate da un programma o dalla macchina virtuale, e possono essere intercettate e gestite. Si puo’ gestire un’eccezione nei seguenti tre modi: n. Non gestire l’eccezione; n. Gestire l’eccezione non appena si verifica; n. Gestire l’eccezione in un altro punto del programma. Se un’eccezione viene ignorata dal programma, allora il programma stesso verrà interrotto producendo un messaggio di errore opportuno. Il messaggio include il tipo di eccezione lanciata e la pila delle chiamate ai metodi che consentono di individuare il punto del programma in cui l’eccezione si e’ verificata. 8

Messaggio di segnalazione di eccezione Se nella classe Esempio assegnassi alla variabile div il valore 0 otterrei il seguente messaggio: Exception in thread "main" java. lang. Arithmetic. Exception: / by zero at Esempio. calc(Esempio. java: 3) at Esempio. main(Esempio. java: 10) generato dalla macchina virtuale che segnala un errore dovuto ad una divisione per zero. 9

Eccezioni controllate Le eccezioni controllate richiedono che il metodo in cui si possono verificare le intercetti e le gestisca direttamente o le elenchi nella clausola throws. 10

Gestione delle Eccezioni Java mette a disposizione dei meccanismi flessibili per individuare e ripristinare gli errori di un programma. La gestione delle eccezioni consente di trasferire il controllo dell’errore dal punto in cui si manifesta al punto del programma in cui è possibile gestire l’errore ripristinando la situazione corretta. L’esecuzione di un programma prevede l’invocazione di metodi in cascata. Quando si verifica un errore, il metodo che lo ha generato non sempre ha la possibilità di porre rimedio ad esso, ma potrà delegare il chiamante a gestire direttamente l’eccezione o a rilanciarla a sua volta. 11

Clausola throw Per lanciare un’eccezione si usa la clausola throw. Questa si inserisce nel punto del programma che genera l’eccezione. Esempio: static int calc(int num 1, int num 2, int div) { if(div == 0) throw new Illegal. Argument. Exception("Divisore non valido"); int val = (num 1 + num 2)/div; return val; } L’eccezione lanciata verrà catturata dal metodo che intende gestirla. Il metodo competente per la gestione dell’eccezione dovrà utilizzare un blocco try – catch. 12

Blocco try - catch try { istruzioni che possono generare l’eccezione } catch(IOException e) { gestore dell’eccezione IOException } catch(Illegal. Argument. Exception e) { gestore dell’eccezione Illegal. Argument. Exception } 13

Il blocco try - catch Per gestire un’eccezione occorre inserire la/e istruzione/i che possono lanciare l’eccezione all’interno di un blocco try. Un blocco try e’ seguito da una o più clausole catch che contengono le istruzioni che servono a gestire la/e eccezione/i. Ogni clausola catch e’ associata ad un tipo di eccezione. Ogni blocco try può avere più clausole catch associate. Ogni clausola catch viene detta gestore di eccezioni. Quando viene eseguito un blocco try, vengono eseguite tutte le istruzioni contenute nel blocco. Se non si verificano eccezioni, l’esecuzione continua poi con le istruzioni che seguono il blocco try (dopo la clausola catch). Se si verifica un’eccezione all’interno di un blocco try, il controllo passa al gestore di eccezioni appropriato (blocco catch). Dopo l’esecuzione delle istruzioni della clausola catch, il controllo passa alle istruzioni che seguono l’intero blocco try – catch. 14

Gestione delle eccezioni Se un’eccezione non viene intercettata e gestita quando si verifica, il controllo viene immediatamente restituito al metodo che ha invocato il metodo che l’ha prodotta. Le eccezioni si propagano finché si incontra un metodo che intercetta e gestisce l’eccezione, oppure finché non termina anche il metodo main. Per intercettare un’eccezione ad un livello più esterno, il metodo che produce l’eccezione deve essere invocato all’interno di un blocco try che possieda la clausola catch appropriata per gestirla. Le eccezioni possono essere propagate da un metodo al chiamante con la clausola throws che segue l’intestazione della definizione del metodo. La clausola throws serve per indicare che quel metodo può lanciare o propagare una particolare eccezione, se si verifica. E’ obbligatorio che un metodo che possa generare un’eccezione controllata o la gestisca direttamente o la propaghi con la clausola throws. public static void main(String[] args) throws IOException { 15

Copia di un file • • • • • // esempio in cui non si gestisce l’eccezione controllata, // ma si segnala che l’applicazione può generarla (throws). import java. io. *; public class Copy. Bytes { public static void main(String[] args) throws IOException { File. Input. Stream in = new File. Input. Stream(args[0]); File. Output. Stream out = new File. Output. Stream(args[1]); int c; while ((c = in. read()) != -1) out. write(c); in. close(); out. close(); } } 16

Copia di un file 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. // esempio in cui si intercettano due eccezioni controllate. import java. io. *; public class Copy { public static void main(String[] args) { try { File. Reader in = new File. Reader(args[0]); File. Writer out = new File. Writer(args[1]); int c; while ((c = in. read()) != -1) out. write(c); in. close(); out. close(); } catch(File. Not. Found. Exception e) { System. err. println(e. get. Message()); System. exit(1); } catch(IOException e) { System. err. println(e. get. Message()); ); System. exit(1); } } } 17

// esempio di gestione di eccezione in un punto diverso da quello in // cui l’eccezione viene generata. public class Esempio { static int calc(int num 1, int num 2, int div) { if(div == 0) throw new Illegal. Argument. Exception("Divisore non valido!"); int val = (num 1 + num 2)/div; return val; } static public void main(String[] args) { int val 1 = 100; int val 2 = 20; int ris = 0; if(args. length > 0){ int div = Integer. parse. Int(args[0]); try { ris = calc(val 1, val 2, div); System. out. println(ris); } catch (Illegal. Argument. Exception e){ System. out. println(e. get. Message()); } } 18

// esempio di gestione di eccezione in un punto diverso da quello in // cui l’eccezione viene generata. In questo caso si effettua anche // il ripristino dell’errore. public class Esempio { static int calc(int num 1, int num 2, int div) { if(div == 0) throw new Illegal. Argument. Exception("Divisore non valido"); int val = (num 1 + num 2)/div; return val; } static public void main(String[] args) { int val 1 = 100, val 2 = 20 , ris = 0 ; boolean done = false; if(args. length > 0){ int div = Integer. parse. Int(args[0]); while (!done){ try { ris = calc(val 1, val 2, div); done = true; } catch (Illegal. Argument. Exception e){ System. out. println(e. get. Message()); div = My. Utility. read. Int("Inserisci un divisore"); } } System. out. println(ris); } } } 19

Clausola finally Al blocco try si puo’ associare la clausola opzionale finally che definisce una sezione di codice che viene eseguita indipendentemente da come si sia usciti dal blocco try. Le istruzioni contenute nel blocco finally verranno eseguite sempre sia in caso di eccezione, che in caso di conclusione normale del blocco try. Spesso si utilizza per gestire risorse (chiusura di file aperti anche in caso di eccezioni) o per garantire che alcune parti dell’algoritmo vengano eseguite comunque. 20