Il passaggio dei parametri Metodi statici Il riferimento this

Presentazione sul tema: "Il passaggio dei parametri Metodi statici Il riferimento this"— Transcript della presentazione:

1 Il passaggio dei parametri Metodi statici Il riferimento this
11/01/2019 Metodi

2 I sottoprogrammi 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 per 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: Possibilità di modularizzare i programmi, rendendoli più leggibili; Riusabilità del Software: possibilità di riutilizzare porzioni di codice in punti diversi del programma o in programmi diversi (evita la duplicazione del codice). 11/01/2019 Metodi

3 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 Parametri formali (specificati nella definizione del sottoprogramma stesso): simboli che rappresentano i dati su cui il sottoprogramma opera Parametri attuali (specificati nella chiamata del sottoprogramma): dati corrispondenti ai parametri formali, su cui il sottoprogramma effettivamente opera In Java i sottoprogrammi si chiamano metodi e sono definiti sempre all’interno di una classe. Parametri in ingresso Valore restituito sottoprogramma 11/01/2019 Metodi

4 Definizione di metodi La dichiarazione di un metodo specifica le istruzioni che verranno eseguite quando il metodo è invocato (chiamato). Quando viene invocato un metodo, il flusso di controllo passa al metodo ed vengono eseguite le istruzioni definite nel metodo. 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. La chiamata puo’ restituire un valore o no, in dipendenza da come e’ stato definito il metodo. 11/01/2019 Metodi

5 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. myMethod(); myMethod compute 11/01/2019 Metodi

6 Passaggio di parametri
Ogni volta che un metodo viene chiamato, i parametri attuali usati nella chiamata vengono copiati nei parametri formali. char calc (int num1, int num2, String message) { int sum = num1 + num2; char result = message.charAt (sum); return result; } ch = obj.calc (25, count, "Hello"); 11/01/2019 Metodi

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

8 Metodi ricorsivi Un metodo puo’ richiamare se stesso. In questo caso il metodo e’ detto ricorsivo. public static int fattoriale(int n){ int ris; if(n>1) ris = n * fattoriale(n-1); else ris = 1; return ris; } … nfat = fattoriale(3); fattoriale(3) richiama fattoriale(2) fattoriale(2) richiama fattoriale(1) fattoriale(1)  1 fattoriale(2)  2* fattoriale(1) fattoriale(3)  3* fattoriale(2)  3*(2* fattoriale(1))3*2*1 11/01/2019 Metodi

9 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. static void sottoprogramma(int a) { //… … a = 2; } // … … int b=3; sottoprogramma(b); System.out.println(“b=”+b); b=3 11/01/2019 Metodi

10 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. public class Dato { public int val; public Dato(int val) { this.val = val; } this.val è il campo val dell’oggetto corrente, val è il parametro formale del costruttore 11/01/2019 Metodi

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

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

13 L’uso di riferimenti 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 11/01/2019 Metodi

14 L’uso di riferimenti 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 11/01/2019 Metodi

15 Metodi di istanza I metodi di istanza hanno sempre un parametro implicito: il riferimento all’oggetto corrente (this) public class Dato { // … … public void incrementa() { this.val++; } in questo caso è equivalente scrivere val++ // uso Dato d = new Dato(1); d.incrementa(); System.out.println(d.val); 2 11/01/2019 Metodi

16 I metodi Il codice seguente è equivalente public class Dato { // … …
public static void incrementa(Dato d) { d.val++; } // uso Dato d = new Dato(1); Dato.incrementa(d); System.out.println(d.val); 2 11/01/2019 Metodi

17 I metodi I due approcci possono coesistere e richiamarsi
public class Dato { // … … public static void incrementa(Dato d) { d.val++; } public void incrementa() { incrementa(this); I due metodi si distinguono per il numero e il tipo di parametri Dato.incrementa ha bisogno di un parametro di tipo Dato, posso utilizzare il riferimento this In questo caso non devo scrivere Dato.incrementa perchè sono all’interno della classe 11/01/2019 Metodi

18 Metodi statici 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) 11/01/2019 Metodi

19 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. 11/01/2019 Metodi

20 Esempio di overloading
float prod (int x) { return x ; } Version 1 float prod (int x, float y) return x*y; Version 2 result = prod (25, 4.32) Invocation 11/01/2019 Metodi

21 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 11/01/2019 Metodi

22 Classe Studente public class Studente {
static private int contatore=0; private int matricola; private String nome, cognome; public Studente(String nome, String cognome) { this.nome = nome; this.cognome = cognome; matricola = contatore++; } public String toString() { int controllo=matricola; controllo += matricola/100; controllo += matricola/10000; controllo = controllo % 100; return nome+” “+cognome+” “+matricola+”/”+controllo; contatore è presente in una unica copia, matricola esiste per ogni oggetto Ad ogni studente viene assegnata una matricola differente 11/01/2019 Metodi

23 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 private int numeroEsami=0; private Esame[] esami = new Esame[30]; public addEsame(Esame esame) { esami[numeroEsame++] = esame; } public int esamiSostenuti() { return numeroEsami; Ovviamente dobbiamo avere una classe Esame opportuna 11/01/2019 Metodi

24 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. 11/01/2019 Metodi

25 Ereditarieta’ Vehicle Car
L’ereditarieta’ consente di derivare una versione specializzata dalla classe padre. 11/01/2019 Metodi

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

27 Esempio Definire una classe non modificabile in grado di memorizzare un intero Creare e riempire un vettore di 10 oggetti della classe appena definita inizializzati con interi positivi minori di 1000 scelti a caso Stampare i valori memorizzati nel vettore Ordinare il vettore e stampare di nuovo i valori Leggere da tastiera dei dati riguardanti un archivio: Richiedere il numero di dati da leggere 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 Ordinare i dati per codice e stampare l’archivio così ordinato È possibile utilizzare il programma per elaborare un archivio memorizzato in un file? 11/01/2019 Metodi

28 public int getCodice() { return codice;
public class Dati { private int codice; public Dati(int val) { codice = val; } public int getCodice() { return codice; public String toString() { return String.valueOf(codice); public int cmp(Dati d) { return codice - d.codice; public static void stampaVettore(Dati[] v) { for(int i=0; i<v.length; i++) { System.out.print(" "+v[i]); System.out.println(); 11/01/2019 Metodi

29 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)); } stampaVettore(v); sort(v); private static void scambia(Dati[]v, int i, int j) { Dati tmp = v[i]; v[i] = v[j]; 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); 11/01/2019 Metodi

30 public class Prodotti extends Dati {
private String descr; public Prodotti(String stringa) { super(Integer.parseInt(stringa.substring(0,3))); descr = stringa.substring(4); } public String toString() { return String.valueOf(getCodice())+' '+descr+'\n'; public static Prodotti[] leggiVettore() { int n = MyUtility.readInt("Quanti prodotti vuoi introdurre? "); Prodotti[] v = new Prodotti[n]; for(int i=0; i<v.length; i++) { v[i] = new Prodotti(MyUtility.readLine("prodotto "+(i+1)+" ")); return v; public static void main(String[] args) { Prodotti[] v = leggiVettore(); stampaVettore(v); sort(v); 11/01/2019 Metodi

31 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. 11/01/2019 Metodi

32 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 11/01/2019 Metodi

33 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. 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. 11/01/2019 Metodi

34 Incapsulamento Methods Client Data
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 11/01/2019 Metodi

35 Modificatori di visibilita’
Modificatori di visibilita’ Modificatore Classi o interfacce Metodi e variabili 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. protected N/A private Non ereditati da alcuna sottoclasse. Non accessibili da nessuna altra classe. 11/01/2019 Metodi

36 L’uso di riferimenti a 2 a 2 a a.val=b.val b 3 b 2 b Chiamata scambio
tmp=3 a 2 a a 3 a b 3 b b 2 b b.val=tmp tmp=? tmp=3 a 2 a Ritorno da scambio b 3 b tmp=a.val a 3 tmp=3 b 2 11/01/2019 Metodi

37 L’uso di riferimenti a 2 a 2 a a=b b 3 b b 3 tmp Chiamata scambio a 2
? tmp tmp a 2 a Ritorno da scambio b 3 b tmp=a a 3 tmp b 2 11/01/2019 Metodi

38 L’uso di riferimenti vet v vet v a=3 v[a]=v[b] 2 a=3 2 b=1 3 b=1 3 ?
tmp tmp vet vet v v a=3 a=3 2 2 tmp=v[a] v[b]=v[a] b=1 3 b=1 3 tmp tmp 11/01/2019 Metodi