Metodi Il passaggio dei parametri Metodi statici Il

Metodi Il passaggio dei parametri Metodi statici Il riferimento this 10/24/2021 Metodi 1

I sottoprogrammi ( o subroutine, o 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 sottoprogramma usa per svolgere il compito assegnato. Vantaggi dell’uso di sottoprogrammi: 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). 10/24/2021 Metodi 2

I sottoprogrammi Un sottoprogramma è una sequenza di istruzioni che vengono attivate a seguito di una chiamata Lo scambio di informazioni fra sottoprogramma e codice 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 sottoprogramma stesso): simboli che rappresentano i dati su cui il sottoprogramma opera l Parametri attuali (specificati nella chiamata del sottoprogramma): dati corrispondenti ai parametri formali, su cui il sottoprogramma effettivamente opera In 10/24/2021 Java i sottoprogrammi si chiamano. Metodi metodi e sono definiti sempre all’interno di 3

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 puo’ restituire un valore o no, in dipendenza da come e’ stato definito il metodo. 10/24/2021 Metodi 4

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(); 10/24/2021 Metodi 5

Passaggio di parametri Ogni volta che un metodo viene chiamato, i parametri attuali usati nella chiamata vengono copiati nei parametri formali. ch = obj. calc (25, count, "Hello"); char calc (int num 1, int num 2, String message) { int sum = num 1 + num 2; char result = message. char. At (sum); return result; } 10/24/2021 Metodi 6

Metodi 1. public class Esempio { Definizione del metodo esempio 2. 3. private static int esempio(int a){ 4. int risultato; 5. risultato = a*2; Parametri formali 6. return risultato; 7. } Valore 8. restituito 9. static public void main(String[] args) 10. int ris = esempio(1); Chiamata del metodo 11. System. out. println(ris); 12. } 13. Parametri 14. } Utilizzo del valore restituito attuali Si noti che le due variabili ris e risultato sono completamente indipendenti fra di loro 10/24/2021 Metodi 7

Metodi ricorsivi Un metodo puo’ richiamare se stesso. In questo caso il metodo e’ detto ricorsivo. 1. public static int fattoriale(int n){ 2. int ris; 3. if(n>1) ris = n * fattoriale(n-1); 4. else ris = 1; 5. return ris; 6. } 7. … 8. nfat = fattoriale(3); fattoriale(3) richiama fattoriale(2) richiama fattoriale(1) 1 fattoriale(2) 2* fattoriale(1) fattoriale(3) 3* fattoriale(2) 3*(2* fattoriale(1)) 3*2*1 10/24/2021 Metodi 8

Il passaggio di parametri per valore Secondo la modalità del passaggio per valore ogni metodo ha una propria zona di memoria per memorizzare i dati (in Java messa a disposizione solo al momento dell’effettivo utilizzo e rilasciata quando non è più necessaria dal garbage collector). Al momento della chiamata del metodo, i parametri attuali vengono ricopiati nei parametri formali, quindi non è possibile riferirsi dal metodo ai valori del codice chiamante. 1. static void sottoprogramma(int a) { 2. //… … 3. a = 2; 4. } 5. 6. // … … 7. int b=3; 8. sottoprogramma(b); 9. System. out. println(“b=”+b); 10. // … … b=3 10/24/2021 Metodi 9

Il riferimento this Esiste un particolare identificatore che fa riferimento sempre all’oggetto corrente: tale riferimento è identificato dalla parola chiave this. A meno di ambiguità si può omettere. 1. public class Dato { 2. 3. public int val; 4. 5. public Dato(int val) { 6. this. val = val; 7. } 8. 9. } 10/24/2021 Metodi this. val è il campo val dell’oggetto corrente, val è il parametro formale del costruttore 10

Il passaggio per valore 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. static void scambia(int a, int b) { int tmp=a; a=b; b=tmp; } Non vi è corrispondenza fra i nomi di metodi diversi // … … int a=2, b=3; scambia(a, b); System. out. println(“a=” +a+“ b=”+b); // … … a=2 b=3 Non ho ottenuto il risultato voluto a causa del passaggio per valore 10/24/2021 Metodi 11

L’uso di riferimenti 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. static void scambia(Dato a, Dato b) { int tmp=a. val; a. val =b. val; b. val =tmp; Tramite i riferimenti accedo allo } stesso oggetto in memoria, in questo caso si è copiato il riferimento // … … Dato a = new Dato(2), b = new Dato(3); scambia(a, b); System. out. println(“a=” +a. val+“ b=”+b. val); // … … a=3 b=2 Tramite l’uso dei riferimenti posso simulare il passaggio per indirizzo 10/24/2021 Metodi 12

L’uso di riferimenti 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. static void scambia(Dato a, Dato b) { Dato tmp = a; a = b; b = tmp; } // … … Dato a=new Dato(2), b= new Dato(3); scambia(a, b); System. out. println(“a=” +a. val+“ b=”+b. val); // … … a=2 b=3 10/24/2021 Metodi 13

L’uso di riferimenti 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. static void scambia(Dato[] v, int i, int j) { Dato tmp = v[a]; v[i] = v[j]; v[j] = tmp; } // … … Dato[] vet = new Dato[5]; vet[1] = new Dato(2); vet[3] = new Dato(3); scambia(vet, 1, 3); System. out. println(“v[1]=” +v[1]. val+“v[3]=”+v[3]. val); // … … a=3 b=2 10/24/2021 Metodi 14

Metodi di istanza I metodi di istanza hanno sempre un parametro implicito: il riferimento all’oggetto corrente (this) 1. public class Dato { 2. 3. // … … 4. 5. public void incrementa() { 6. this. val++; 7. } 8. 9. } in questo caso è equivalente scrivere val++ 1. 2. 3. 4. // uso Dato d = new Dato(1); d. incrementa(); System. out. println(d. val); 2 10/24/2021 Metodi 15

I metodi Il codice seguente è equivalente 1. public class Dato { 2. 3. // … … 4. 5. public static void incrementa(Dato d) { 6. d. val++; 7. } 8. 9. } 1. 2. 3. 4. // uso Dato d = new Dato(1); Dato. incrementa(d); System. out. println(d. val); 2 10/24/2021 Metodi 16

I metodi I due approcci possono coesistere e richiamarsi 1. public class Dato { I due metodi si 2. distinguono per il numero 3. // … … e il tipo di parametri 4. 5. public static void incrementa(Dato d) { 6. d. val++; 7. } 8. 9. public void incrementa() { 10. incrementa(this); 11. } 12. } Dato. incrementa ha bisogno di un parametro di tipo Dato, posso utilizzare il riferimento this 10/24/2021 In questo caso non devo scrivere Dato. incrementa perchè sono all’interno della classe Metodi 17

Metodi statici sono metodi che non fanno riferimento in maniera esplicita a istanze di una classe. Possono fare riferimento solo a campi statici della stessa classe (informazioni presenti in una unica copia per tutte le istanze della classe stessa) Un metodo di istanza che modifica lo stato dell’oggetto, dovrebbe essere definito come void. Un metodo può restituire un riferimento o un valore (tipo base) 10/24/2021 Metodi 18

Overloading dei metodi L’overloading di metodi e’ il processo attraverso cui e’ possibile usare lo stesso noime per piu’ metodi. La segnatura di ciascun metodo deve essere unica. La segnatura include il numero, il tipo e l’ordine dei parametri. Il compilatore deve essere in grado di determinare quale versione del metodo deve essere invocata analizzandone I parametri passati. Il tipo del valore restituito non fa parte della segnatura. 10/24/2021 Metodi 19

Esempio di overloading Version 2 Version 1 float prod (int x) { return x +. 375; } float prod (int x, float y) { return x*y; } Invocation result = prod (25, 4. 32) 10/24/2021 Metodi 20

Costruttori I costruttori sono dei metodi particolari richiamati attraverso l’operatore new Servono per creare una nuova istanza (oggetto) di una certa classe Hanno per nome il nome della classe ogni classe ne può avere più di uno Si distinguono per il numero ed il tipo dei parametri 10/24/2021 Metodi 21

Classe Studente 1. public class Studente { contatore è presente in 2. una unica copia, 3. static private int contatore=0; matricola esiste per ogni 4. private int matricola; oggetto 5. private String nome, cognome; 6. 7. public Studente(String nome, String cognome) { 8. this. nome = nome; Ad ogni studente viene 9. this. cognome = cognome; assegnata una matricola 10. matricola = contatore++; differente 11. } 12. 13. public String to. String() { 14. int controllo=matricola; 15. controllo += matricola/100; 16. controllo += matricola/10000; 17. controllo = controllo % 100; 18. return nome+” “+cognome+” “+matricola+”/”+controllo; 19. } 20. } 10/24/2021 Metodi 22

Classe Studente Cosa manca alla classe Studente: La possibilità di conoscere (non modificare) nome, cognome, matricola La possibilità di memorizzare e conoscere gli esami sostenuti 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. private int numero. Esami=0; private Esame[] esami = new Esame[30]; public add. Esame(Esame esame) { esami[numero. Esame++] = esame; } public int esami. Sostenuti() { return numero. Esami; } Ovviamente dobbiamo avere una classe Esame opportuna 10/24/2021 Metodi 23

Ereditarieta’ L’ereditarieta’ e’ un meccanismo che consente al programmatore di derivare una nuova classe da una esistente. La classe esistente e’ detta padre o superclasse La classe derivata e’ detta figlia o sottoclasse. La classe figli eredita le caratteristiche della classe padre, cioe’ I metodi e I dati definiti nella superclasse. 10/24/2021 Metodi 24

Ereditarieta’ Vehicle Car L’ereditarieta’ consente di derivare una versione specializzata dalla classe padre. 10/24/2021 Metodi 25

Derivare sottoclassi In Java, si usa la parola riservata extends per stabilire una relazione di ereditarieta’. class Car extends Vehicle { // class contents } 10/24/2021 Metodi 26

Esempio 1. Definire una classe non modificabile in grado di memorizzare un intero 2. Creare e riempire un vettore di 10 oggetti della classe appena definita inizializzati con interi positivi minori di 1000 scelti a caso 3. Stampare i valori memorizzati nel vettore 4. Ordinare il vettore e stampare di nuovo i valori 5. Leggere da tastiera dei dati riguardanti un archivio: 1. Richiedere il numero di dati da leggere 2. Richiedere i dati organizzati per riga: i primi tre caratteri sono cifre decimali e rappresentano il codice del prodotto, segue uno spazio, poi la descrizione del prodotto: (esempio) 123 viti 6. Ordinare i dati per codice e stampare l’archivio così ordinato 7. È possibile utilizzare il programma per elaborare un archivio memorizzato in un file? 10/24/2021 Metodi 27

1. public class Dati { 2. 3. private int codice; 4. 5. public Dati(int val) { 6. codice = val; 7. } 8. 9. public int get. Codice() { 10. return codice; 11. } 12. 13. public String to. String() { 14. return String. value. Of(codice); 15. } 16. 17. public int cmp(Dati d) { 18. return codice - d. codice; 19. } 20. 21. public static void stampa. Vettore(Dati[] v) { 22. for(int i=0; i<v. length; i++) { 23. System. out. print(" "+v[i]); 24. } 25. System. out. println(); 26. } 10/24/2021 Metodi 28

1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. } public static void main(String[] args) { Dati[] v = new Dati[10]; for(int i=0; i<v. length; i++) { v[i] = new Dati((int) (Math. random()*1000)); } stampa. Vettore(v); sort(v); stampa. Vettore(v); } private Dati v[i] v[j] } static void scambia(Dati[]v, int i, int j) { tmp = v[i]; = v[j]; = tmp; public static void sort(Dati[] v) { for(int i=0; i<v. length-1; i++) { for(int j=v. length-1; j>i; j--) { if(v[j-1]. cmp(v[j])>0) { scambia(v, j, j-1); } } 10/24/2021 Metodi 29

1. public class Prodotti extends Dati { 2. 3. private String descr; 4. 5. public Prodotti(String stringa) { 6. super(Integer. parse. Int(stringa. substring(0, 3))); 7. descr = stringa. substring(4); 8. } 9. 10. public String to. String() { 11. return String. value. Of(get. Codice())+' '+descr+'n'; 12. } 13. 14. public static Prodotti[] leggi. Vettore() { 15. int n = My. Utility. read. Int("Quanti prodotti vuoi introdurre? "); 16. Prodotti[] v = new Prodotti[n]; 17. for(int i=0; i<v. length; i++) { 18. v[i] = new Prodotti(My. Utility. read. Line("prodotto "+(i+1)+" ")); 19. } 20. return v; 21. } 22. 23. public static void main(String[] args) { 24. Prodotti[] v = leggi. Vettore(); 25. stampa. Vettore(v); 26. sort(v); 27. stampa. Vettore(v); 28. } 29. 30. } 10/24/2021 Metodi 30

Scope dei dati. Lo scope dei dati è la porzione di programma nella quale quei dati possono essere usati (referenziati). I dati definiti a livello di classe possono essere usati da tutti i metodi definiti in quella classe. I dati dichiarati all’interno di un metodo possono essere usati solo in quel metodo. I dati dichiarati all’interno di un metodo sono chiamati dati locali. 10/24/2021 Metodi 31

Modificatori di visibilità In Java, si realizza l’incapsulamento attraverso l’uso di una serie di modificatori di visibilita’. Un modificatore in Java e’ una parola riservata che specifica caratteristiche particolari di un dato o di un metodo. Si usa il modoficatore final per definire una costante. Java ha tre modificatori di visibilita’: public, private, e protected 10/24/2021 Metodi 32

Modificatori di visibilità I membri di una classe (dati e metodi) che sono dichiarati public, sono accessibili da qualunque altra classe. I membri dichiarati senza modificatore di visibilita’ hanno una visibilita’ di default e sono accessibili da tutte le classi del medesimo package. 1. Come regola generale, nessun dato dovrebbe essere dichiarato public. I metodi che forniscono servizi accessibili da altre classi devono essere dichiarati public. I metodi pubblici vengono chiamati metodi di servizio o di interfaccia. 10/24/2021 Metodi 33

Incapsulamento Un oggetto incapsulato puo’ essere visto come una black box. Il suo funzionamento interno e’ nascosto al cliente, che puo’ solo invocare i metodi di inerfaccia. Methods Client Data 10/24/2021 Metodi 34

Modificatori di visibilita’ Modificatore Classi o interfacce Default (nessun modificatore) Visibili nel proprio package. Ereditati da ogni sottoclasse nello stesso package della loro classe. Accessibili da ogni classe nello stesso package della loro classe. public Visibile ovunque. Ereditati da tutte le sottoclassi. Accessibili ovunque. N/A Ereditati da tutte le sottoclassi. Accessibili da ogni classe nello stesso package della loro classe. N/A Non ereditati da alcuna sottoclasse. Non accessibili da nessuna altra classe. protected private 10/24/2021 Metodi e variabili Metodi 35

L’uso di riferimenti a b 2 3 a 2 a b 2 b Chiamata scambio tmp=3 a 2 a b 3 b a 3 a b 2 b tmp=? a 2 a b 3 b b. val=tmp tmp=3 Ritorno da scambio tmp=a. val tmp=3 10/24/2021 a. val=b. val Metodi a 3 b 2 36

L’uso di riferimenti a 2 a a=b b b 3 3 b tmp Chiamata scambio a b 2 a 3 2 a b 3 b b ? b=tmp tmp a 2 a b 3 b Ritorno da scambio tmp=a tmp 10/24/2021 a Metodi a 3 b 2 37

L’uso di riferimenti vet v vet a=3 2 2 b=1 3 ? 3 tmp 2 3 v[a]=v[b] b=1 v v a=3 tmp vet 2 tmp=v[a] 3 b=1 a=3 b=1 v[b]=v[a] tmp 10/24/2021 v Metodi 38