Esempi JAVA: differenze tra le versioni

Da Bioingegneria Elettronica e Informatica.
(→‎Passaggio per valore e Passaggio per reference)
(→‎Passaggio per valore e Passaggio per reference)
Riga 114: Riga 114:
 
</syntaxhighlight>
 
</syntaxhighlight>
  
−
== Passaggio per valore e Passaggio per reference ==
+
== Scambio di due elementi all'interno di un vettore ==
−
In questo paragrafo verrà mostrata la funzione di scambio di due variabili presentando:
+
−
# la versione sintatticamente corretta ma '''non funzionante''' passando le variabili per valore;
+
−
# la versione sintatticamente corretta e funzionante passando le variabili per riferimento.
+
  
−
=== Passaggio per valore ===
+
<syntaxhighlight lang="java" line>
 +
public class Principale {
 +
 
 +
public static void main(String[] args) {
 +
 +
new Principale().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]);
 +
 +
 +
// Generalizzazione a vettore formato da N elementi in cui indico le componenti da scambiare
 +
// Vettore formato da N elementi
 +
int N = 10;
 +
int i = 0;
 +
int[] vett = new int[N];
 +
 +
for(i = 0; i < N; i++)
 +
vett[i] = i+1;
 +
 +
int ind1 = 3;
 +
int ind2 = 8;
 +
// Stampo il vettore prima dello scambio
 +
for(i = 0; i < N; i++)
 +
System.out.print(vett[i] + " ");
 +
System.out.println();
 +
 +
// Effettuo lo scambio
 +
scambia_componenti(vett, ind1, ind2);
 +
 
 +
// Stampo il vettore dopo dello scambio
 +
for(i = 0; i < N; i++)
 +
System.out.print(vett[i] + " ");
 +
System.out.println();
 +
}
 +
 +
/**
 +
* Funzione scambia funzionante
 +
* @param V
 +
*/
 +
public void scambia(int[] V) {
 +
int temp;
 +
temp = V[0];
 +
V[0] = V[1];
 +
V[1] = temp;
 +
 +
}
 +
 +
        /**
 +
* Funzione di scambio delle componenti in posizione c1 e c2 del vettore V
 +
* @param V
 +
* @param c1
 +
* @param c2
 +
*/
 +
public void scambia_componenti(int[] V, int c1, int c2) {
 +
int temp;
 +
temp = V[c1];
 +
V[c1] = V[c2];
 +
V[c2] = temp;
 +
}
 +
}
 +
</syntaxhighlight>

Versione delle 10:45, 22 mar 2017

Hello World

Esercizio introduttivo a JAVA. Il seguente codice mostra a video la stringa "Hello World !" 

  1. /* Questo è il primo programma in JAVA
  2.  * e inizia con un commento multilinea
  3.  */
  4.  
  5. // Commento su singola linea
  6.  
  7. /**
  8.  * Uso della javadoc 
  9.  * Questo programma deve stampare sullo standard output, ovvero la console,
  10.  * la stringa "Hello World !"
  11.  * 
  12.  * @author antonio
  13.  *
  14.  */
  15.  
  16. public class Principale {
  17.  
  18. 	/**
  19. 	 * Metodo di avvio del programma
  20. 	 * @param args argomenti passati dalla linea di comando
  21. 	 */
  22. 	public static void main(String[] args) {
  23.  
  24. 		// Standard output
  25. 		System.out.println("Hello World !");	
  26. 	}
  27. }

Uso delle funzioni: Doppio e Somma

  1. /** Programma per mostrare il funzionamento di:
  2.  *  1. Funzione chiamante (main) e funzione chiamata;
  3.  *  2. Variabili locali e parametri (valori) attuali; 
  4.  *  3. Passaggio per Valore;
  5.  * 
  6.  * @author antonio
  7.  * 
  8.  */
  9. public class Principale {
  10.  
  11. 	public static void main(String[] args) {
  12.  
  13. 		new Principale().run();
  14. 	}
  15.  
  16. 	public void run() {
  17.                 // Dichiarazione e inizializzazione delle variabili origin, origin2 e result
  18. 		int origin = 3;
  19. 		int origin2 = 5;
  20. 		int result = 0;
  21.  
  22. 		System.out.println("Doppio di una variabile");
  23.  
  24. 		// Stampa in console del valore attuale di origin
  25. 		System.out.println("Il valore di origin è: " + origin);
  26.  
  27.                 /* Calcolo il doppio della variabile origin:
  28.                  * 1. chiamo la funzione doppio
  29.                  * 2. salvo il risultato nella variabile result
  30.                  */
  31. 		result = doppio(origin);
  32.  
  33. 		// Stampa in console il valore di result
  34. 		System.out.println("Il valore di result è: " + result);
  35.  
  36.  
  37. 		System.out.println("Somma di due variabili");
  38.  
  39. 		// Stampa in console del valore attuale di origin e origin2
  40. 		System.out.println("Il valore di origin è: " + origin);
  41. 		System.out.println("Il valore di origin2 è: " + origin2);
  42.  
  43.                 // Calcolo la somma di origin e origin2
  44. 		result = somma(origin, origin2);
  45.  
  46.                 // Stampa in console il valore di result
  47. 		System.out.println("Il valore di result è: " + result);
  48. 	}
  49.  
  50. 	/**
  51. 	 * Funzione per calcolare il doppio di un valore
  52. 	 * @param val
  53. 	 * @return
  54. 	 */
  55. 	public int doppio(int val) {
  56.                 // Dichiaro la variabile res per salvare il doppio della variabile val
  57. 		int res = 0;
  58. 		res = val * 2;
  59.  
  60.                 // Restituzione di res
  61. 		return res;
  62. 	}
  63.  
  64. 	/**
  65. 	 * Funzione per calcolare la somma di due addendi
  66. 	 * @param add1
  67. 	 * @param add2
  68. 	 * @return
  69. 	 */
  70. 	public int somma(int add1, int add2) {
  71.  
  72.                 // Codice compatto che fa la somma di add1 e add2 e restituisce il risultato
  73. 		return add1 + add2;
  74. 	}
  75. }

Scambio di due elementi all'interno di un vettore

  1. public class Principale {
  2.  
  3. 	public static void main(String[] args) {
  4.  
  5. 		new Principale().run();
  6. 	}
  7.  
  8. 	public void run() {
  9. 		// Vettore formato da due elementi
  10. 		int[] v = {3,5};
  11.  
  12. 		// Stampo il valore delle due variabili prima dello scambio
  13. 		System.out.println("La prima componente del vettore vale: " + v[0]);
  14. 		System.out.println("La seconda componente del vettore vale: " + v[1]);
  15.  
  16. 		// Effettuo lo scambio
  17. 		scambia(v);
  18.  
  19. 		// Stampo il valore delle due variabili dopo lo scambio
  20. 		System.out.println("La prima componente del vettore vale: " + v[0]);
  21. 		System.out.println("La seconda componente del vettore vale: " + v[1]);
  22.  
  23.  
  24. 		// Generalizzazione a vettore formato da N elementi in cui indico le componenti da scambiare
  25. 		// Vettore formato da N elementi
  26. 		int N = 10;
  27. 		int i = 0;
  28. 		int[] vett = new int[N];
  29.  
  30. 		for(i = 0; i < N; i++)
  31. 			vett[i] = i+1;
  32.  
  33. 		int ind1 = 3;
  34. 		int ind2 = 8;
  35. 		// Stampo il vettore prima dello scambio
  36. 		for(i = 0; i < N; i++)
  37. 			System.out.print(vett[i] + " ");
  38. 		System.out.println();
  39.  
  40. 		// Effettuo lo scambio
  41. 		scambia_componenti(vett, ind1, ind2);
  42.  
  43. 		// Stampo il vettore dopo dello scambio
  44. 		for(i = 0; i < N; i++)
  45. 			System.out.print(vett[i] + " ");
  46. 		System.out.println();
  47. 	}
  48.  
  49. 	/**
  50. 	 * Funzione scambia funzionante
  51. 	 * @param V
  52. 	 */
  53. 	public void scambia(int[] V) {
  54. 		int temp;
  55. 		temp = V[0];
  56. 		V[0] = V[1];
  57. 		V[1] = temp;
  58.  
  59. 	}
  60.  
  61.         /**
  62. 	 * Funzione di scambio delle componenti in posizione c1 e c2 del vettore V 
  63. 	 * @param V
  64. 	 * @param c1
  65. 	 * @param c2
  66. 	 */
  67. 	public void scambia_componenti(int[] V, int c1, int c2) {
  68. 		int temp;
  69. 		temp = V[c1];
  70. 		V[c1] = V[c2];
  71. 		V[c2] = temp;
  72. 	}
  73. }
Estratto da "http://www.vitoantoniobevilacqua.it/wiki/index.php?title=Esempi_JAVA&oldid=415"