Variabili passate come parametri

Il programma Locali.java chiarisce un punto che può risultare poco chiaro nella programmazione con procedure e funzioni.

/*
  Esempio sull'uso di variabili locali.
*/

class Locali {
  static void uno(int x) {
    x=x+1;
  }

  static int due(int x) {
    x=x+1;
    return x;
  }

  public static void main(String[] args) {
    int x=5;
    int y;

    uno(x);
    System.out.println(x);

    y=due(x);
    System.out.println(x);
    System.out.println(y);
  }
}
Ci poniamo il seguente problema: cosa viene stampato? Questo non è difficile, se si seguono esattamente le regole sul passaggio dei parametri che sono state specificate fino ad ora. A volte però vengono date risposte errate, del tipo ``viene stampato per tre volte il numero 6'', oppure ``viene stampato 5, poi due volte 6''. La risposta esatta è:

viene stampato due volte 5, poi una volta 6

Se il risultato che ci si aspettava è diverso, allora non si sono seguite correttamente le regole di passaggio sulle procedure.

Analizziamo quindi l'esecuzione del programma:

  1. viene creata la variabile x e ci viene messo 5;
  2. si crea la variabile y;
  3. si chiama la procedura uno, passando il valore di x (che in questo caso è 5);
  4. la procedura uno crea una sua variabile che chiama x, e in questa variabile ci mette il valore passato, cioè 5; è importante notare che questa variabile, anche se ha lo stesso nome, non è la stessa di quella che sta nel programma;
  5. la variabile x interna alla procedura uno viene incrementata;
  6. questo termina l'esecuzione di uno;
  7. si esegue System.out.println(x); fino a questo punto, la variabile x non è stata modificata: infatti, la procedura uno ha modificato la sua variabile x, che non è la stessa del programma. Quindi, si stampa il valore 5.
La chiamata alla funzione due è simile: la variabile x che viene incrementata è una variabile locale della funzione, e non è la stessa del programma. La funzione due permette di vedere come l'unico modo che una funzione ha di influenzare il programma è quello di ritornare dei valori: tutte le altre modifiche vengono ignorate dal programma. In questo caso, la variabile x interna alla funzione viene modificata, ma questa modifica non si riflette sulla variabile x del programma, ma soltanto nel fatto che il valore che la procedura rimanda al programma (che è il valore di x aumentato di 1) viene memorizzato nella variabile y.