Come sappiamo, i metodi accettano delle variabili in input. Questa operazione viene chiamata “passaggio di parametri”.
Una variabile, chiamiamola X, di tipo primitivo, viene passata ad un metodo per valore (passaggio parametri per valore): il metodo crea una copia della variabile X, chiamiamola X1, in input, e userà questa al suo interno. Perciò, tutte le modifiche fatte su X1, non influenzeranno in nessun modo X, che manterrà il suo valore originale.
Esempio:
public class provatre {
public int helloR(int x) {
x++;
return x;
}
public static void main(String[] args) {
provatre p = new provatre();
int count = 15;
p.helloR(count);
System.out.println(count);
}
}
L’output sarà: 15
Le modifiche fatte all’interno del metodo, non cambieranno il valore di count.
Queste istruzioni:
Persona p = new Persona(); p.nome = "Pippo"; Persona p1 = new Persona(); p.nome = "Pluto";
nella memoria, ovviamente semplificando molto, corrispondono a:
Nella variabile p, o anche p1, non c’è l’oggetto Persona, ma il suo indirizzo di memoria (anche detto reference).
Un oggetto X viene passato ad un metodo per riferimento: il metodo crea un’oggetto X1 che contiene un riferimento all’oggetto X. Le modifiche fatte su X1, verranno perciò riportate su X.
Esempio:
public class provatre {
public void hello(Impiegato x) {
x.setNome("pippo");
}
public static void main(String[] args) {
provatre p = new provatre();
Impiegato tmp = new Impiegato();
tmp.setNome("paperino");
p.hello(tmp);
System.out.println(tmp.getNome());
}
}
L’output prodotto sarà: Pippo
La memoria, può essere così schematizzata:
Esempio:
public class provatre {
public void helloDue(Impiegato x) {
x.setNome("pippo");
(**) x = new Impiegato();
x.setNome("pluto");
}
public static void main(String[] args) {
provatre p = new provatre();
Impiegato tmp = new Impiegato();
tmp.setNome("paperino");
p.helloDue(tmp);
System.out.println(tmp.getNome());
}
}
Output: pippo
Non verrà stampato “pluto”
Questo perché, fino alla riga (**), in memoria si ha questa situazione:
Invece, dopo la (**):
X punterà al nuovo oggetto, quindi conterrà il nuovo riferimento; di conseguenza le modifiche su X (sempre dopo (**)), non impatteranno P.