Le funzioni in Java: differenze tra le versioni

Da Bioingegneria Elettronica e Informatica.
(→‎Passaggio dei parametri ad una funzione)
(→‎Passaggio dei parametri ad una funzione)
Riga 29: Riga 29:
 
== Passaggio dei parametri ad una funzione ==
 
== Passaggio dei parametri ad una funzione ==
 
In Java, è possibile passare i parametri ad una funzione in due modalità:  
 
In Java, è possibile passare i parametri ad una funzione in due modalità:  
−
# Passaggio per valore ("pass by value"): si tratta di un passaggio unidirezionale; il valore del parametro effettivo viene copiato nella variabile della funzione chiamata che rappresenta il parametro formale. Se la funzione chiamata lo modifica, la funzione chiamante non potrà vedere questa modifica.
+
# '''Passaggio per valore''' ("pass by value"): si tratta di un passaggio unidirezionale; il valore del parametro effettivo viene copiato nella variabile della funzione chiamata che rappresenta il parametro formale. Se la funzione chiamata lo modifica, la funzione chiamante non potrà vedere questa modifica.
−
# Passaggio per riferimento ("pass by reference"): in questo caso il passaggio è potenzialmente bidirezionale; La funzione invocata riceve un riferimento al parametro effettivo; quindi se, nella funzione chiamata, avviene una modifica al parametro passato per riferimento, la modifica sarà visibile anche alla funzione chiamante.
+
# '''Passaggio per riferimento''' ("pass by reference"): in questo caso il passaggio è potenzialmente bidirezionale; La funzione invocata riceve un riferimento al parametro effettivo; quindi se, nella funzione chiamata, avviene una modifica al parametro passato per riferimento, la modifica sarà visibile anche alla funzione chiamante.
  
 
Il seguente esempio mostra le differenze delle due modalità di passaggio dei parametri ad una funzione; tali differenze sono evidenziate attraverso l'implementazione del metodo di scambio di due variabili.
 
Il seguente esempio mostra le differenze delle due modalità di passaggio dei parametri ad una funzione; tali differenze sono evidenziate attraverso l'implementazione del metodo di scambio di due variabili.
  
 
=== Passaggio per valore ===
 
=== Passaggio per valore ===
−
In questa la versione, '''sintatticamente corretta ma non funzionante''', le variabili sono passate alla funzione di scambia per valore. Poiché sintatticamente corretto, sarà possibile eseguire il codice che tuttavia non produrrà l'output desiderato.
+
In questa versione, '''sintatticamente corretta ma non funzionante''', le variabili sono passate alla funzione di scambia per valore. Poiché sintatticamente corretto, sarà possibile eseguire il codice che tuttavia non produrrà l'output desiderato.
  
 
<syntaxhighlight lang="java" line>
 
<syntaxhighlight lang="java" line>
Riga 79: Riga 79:
  
 
=== Passaggio per riferimento===
 
=== Passaggio per riferimento===
 +
In questa versione, si utilizza un vettore passandolo per riferimento alla funzione. In questo modo sarà possibile lavorare direttamente sul vettore nella funzione di scambio e la modifica nel corpo della funzione si rifletterà sul vettore originario.
 +
 +
<syntaxhighlight lang="java" line>
 +
public class Principale {
 +
 +
public static void main(String[] args) {
 +
 +
new Principale5().run();
 +
 +
}
 +
 +
public void run() {
 +
// Vettore formato da due elementi
 +
int[] v = {3,5};
 +
 +
// Stampo il valore delle due variabili prima dello scambio
 +
System.out.println("La prima componente del vettore vale: " + v[0]);
 +
System.out.println("La seconda componente del vettore vale: " + v[1]);
 +
 +
// Effettuo lo scambio
 +
scambia(v);
 +
 +
// Stampo il valore delle due variabili dopo lo scambio
 +
System.out.println("La prima componente del vettore vale: " + v[0]);
 +
System.out.println("La seconda componente del vettore vale: " + v[1]);
 +
}
 +
 +
/**
 +
* Funzione scambia funzionante
 +
* @param V
 +
*/
 +
public void scambia(int[] V) {
 +
int temp;
 +
temp = V[0];
 +
V[0] = V[1];
 +
V[1] = temp;
 +
 +
}
 +
}
 +
</syntaxhighlight>
  
 
== Esempi Applicativi ==
 
== Esempi Applicativi ==

Versione delle 08:59, 22 mar 2017

Introduzione alle funzioni

È possibile unire gruppi di istruzioni per formare delle "funzioni" usate per evitare di replicare porzioni di codice sorgente più volte. Invocare una funzione significa mandare in esecuzione la porzione di codice che la costituisce. Se una funzione è invocata più volte, allora la porzione di codice è eseguita più volte: il vantaggio è dunque quello di poter avere tante chiamate ma una sola porzione di codice.

Dichiarazione, definizione e chiamata di una funzione

In JAVA è possibile dichiarare e definire una funzione nel seguente modo: 

modificatore_visibilità tipo_restituito nomeFunzione (tipo1 param1, tipo2 param2, ..., tipoN paramN) 
{
    // blocco di codice appartenente al metodo
 
    return varTipo;
}

Il codice precedente definisce una funzione chiamata nomeFunzione che accetta come ingresso (dominio) N variabili (param1, param2, ..., paramN) ognuna con un determinato tipo e restituisce come uscita (codominio) una variabile il cui tipo è tipo_restituito.

Durante il flusso del programma, è possibile chiamare una funzione attraverso il suo nome, inserendo come argomento le necessarie variabili coerentemente con il dominio definito e assegnando il risultato ad una variabile dello stesso tipo di tipo_restituito'. 

... // Serie di istruzioni
 
tipo_restituito var = nomeFunzione(var1, var2, ..., varN);
 
... // Serie di istruzioni

Passaggio dei parametri ad una funzione

In Java, è possibile passare i parametri ad una funzione in due modalità:

  1. Passaggio per valore ("pass by value"): si tratta di un passaggio unidirezionale; il valore del parametro effettivo viene copiato nella variabile della funzione chiamata che rappresenta il parametro formale. Se la funzione chiamata lo modifica, la funzione chiamante non potrà vedere questa modifica.
  2. Passaggio per riferimento ("pass by reference"): in questo caso il passaggio è potenzialmente bidirezionale; La funzione invocata riceve un riferimento al parametro effettivo; quindi se, nella funzione chiamata, avviene una modifica al parametro passato per riferimento, la modifica sarà visibile anche alla funzione chiamante.

Il seguente esempio mostra le differenze delle due modalità di passaggio dei parametri ad una funzione; tali differenze sono evidenziate attraverso l'implementazione del metodo di scambio di due variabili.

Passaggio per valore

In questa versione, sintatticamente corretta ma non funzionante, le variabili sono passate alla funzione di scambia per valore. Poiché sintatticamente corretto, sarà possibile eseguire il codice che tuttavia non produrrà l'output desiderato. 

  1. public class Principale {
  2.  
  3. 	public static void main(String[] args) {
  4.  
  5. 		new Principale().run();
  6.  
  7. 	}
  8.  
  9. 	public void run() {
  10. 		// Dichiaro due variabili a e b da scambiare.
  11. 		int a = 3;
  12. 		int b = 5;
  13.  
  14. 		// Stampo il valore delle due variabili prima dello scambio.
  15. 		System.out.println("La variabile a vale: " + a);
  16. 		System.out.println("La variabile b vale: " + b);
  17.  
  18. 		// Effettuo lo scambio
  19. 		scambia(a, b);
  20.  
  21. 		// Stampo il valore delle due variabili dopo lo scambio.
  22. 		System.out.println("La variabile a vale: " + a);
  23. 		System.out.println("La variabile b vale: " + b);
  24.  
  25.                 // Le variabili a e b hanno mantenuto lo stesso valore di partenza.
  26. 	}
  27.  
  28. 	/**
  29. 	 * Funzione scambia non funzionante
  30. 	 * @param A
  31. 	 * @param B
  32. 	 */
  33. 	public void scambia(int A, int B) {
  34. 		int temp = A;
  35. 		A = B;
  36. 		B = temp;
  37. 	}
  38. }

Passaggio per riferimento

In questa versione, si utilizza un vettore passandolo per riferimento alla funzione. In questo modo sarà possibile lavorare direttamente sul vettore nella funzione di scambio e la modifica nel corpo della funzione si rifletterà sul vettore originario. 

  1. public class Principale {
  2.  
  3. 	public static void main(String[] args) {
  4.  
  5. 		new Principale5().run();
  6.  
  7. 	}
  8.  
  9. 	public void run() {
  10. 		// Vettore formato da due elementi
  11. 		int[] v = {3,5};
  12.  
  13. 		// Stampo il valore delle due variabili prima dello scambio
  14. 		System.out.println("La prima componente del vettore vale: " + v[0]);
  15. 		System.out.println("La seconda componente del vettore vale: " + v[1]);
  16.  
  17. 		// Effettuo lo scambio
  18. 		scambia(v);
  19.  
  20. 		// Stampo il valore delle due variabili dopo lo scambio
  21. 		System.out.println("La prima componente del vettore vale: " + v[0]);
  22. 		System.out.println("La seconda componente del vettore vale: " + v[1]);
  23. 	}
  24.  
  25. 	/**
  26. 	 * Funzione scambia funzionante
  27. 	 * @param V
  28. 	 */
  29. 	public void scambia(int[] V) {
  30. 		int temp;
  31. 		temp = V[0];
  32. 		V[0] = V[1];
  33. 		V[1] = temp;
  34.  
  35. 	}
  36. }

Esempi Applicativi

Estratto da "http://www.vitoantoniobevilacqua.it/wiki/index.php?title=Le_funzioni_in_Java&oldid=410"