Parametri di funzione in Java

1. Passando argomenti

E ora inizia il divertimento. Probabilmente sai già da metodi del genere System.out.println()che possiamo passare argomenti ai metodi. Una volta che siamo all'interno del metodo, li chiamiamo parametri. In effetti, i parametri migliorano notevolmente i vantaggi che otteniamo dalla creazione e dall'utilizzo di metodi.

Come si dichiara un metodo con parametri? In realtà è abbastanza semplice:

public static void name(parameters)
{
  method body
}

Dove name è il nome univoco del metodo e method body rappresenta i comandi che compongono il metodo. Ed parameters è un segnaposto per i parametri del metodo, separati da virgole. Descriviamo questo modello in modo più dettagliato:

public static void name(Type1 name1, Type2 name2, Type3 name3)
{
  method body
}

Esempi:

public static void print(String str)
{
}

public static void print(String str, int count)
{
}

public static void write(int x, int y)
{
}

Se non vogliamo che il metodo abbia parametri, lasciamo vuote le parentesi.

I parametri sono variabili speciali all'interno di un metodo. Con il loro aiuto, puoi passare vari valori al metodo quando viene chiamato.

Ad esempio, scriviamo un metodo che visualizza una stringa di testo un determinato numero di volte.

Sai già come scrivere il codice per visualizzare più volte una stringa sullo schermo. Ma quale stringa dovresti stampare? E quante volte? Per questo abbiamo bisogno dei parametri.

Il codice che fa questo sarebbe simile a questo:

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.println(text);
   }

   public static void main(String[] args)
   {
     printLines("Hi", 10);
     printLines("Bye", 20);
   }
}

Ogni volta che viene chiamato un metodo, ai suoi parametri vengono assegnati i valori passati, e solo allora iniziamo ad eseguire i comandi all'interno del metodo.

2. Argomenti

Vorrei attirare un po' di più la vostra attenzione sulla chiamata di un metodo con parametri.

I valori passati al metodo sono generalmente chiamati argomenti quando vengono passati al metodo.

Diamo un'occhiata a un altro esempio:

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.println(text);
   }

   public static void main(String[] args)
   {
     printLines("Hi", 10);
     printLines("Bye", 20);
   }
}

Quando il printLines metodo è stato chiamato per la prima volta, ai suoi parametri sono stati assegnati i seguenti valori:
String text = "Hi", int count = 10.

Quando il printLinesmetodo è stato chiamato la seconda volta, ai suoi parametri sono stati assegnati valori diversi:
String text = "Bye", int count = 20.

I parametri non sono né più né meno delle variabili a cui vengono assegnati determinati valori quando viene chiamato un metodo. I valori "Hi", "Bye", 10, e 20sono essi stessi chiamati argomenti."

3. Nomi di variabili in conflitto quando si chiama un metodo

Le variabili possono essere utilizzate come argomenti del metodo. Questo è semplice e comprensibile, ma può potenzialmente produrre alcune difficoltà. Torniamo allo stesso esempio, ma questa volta sposteremo gli argomenti in variabili separate:

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.print(text);
   }

   public static void main(String[] args)
   {
     String str = "Hi";
     int n = 10;
     printLines(str, n);
   }
}

Fin qui tutto bene: abbiamo una strvariabile. Il suo valore viene assegnato al textparametro quando viene chiamato il metodo. Abbiamo una nvariabile. Il suo valore viene assegnato al countparametro quando viene chiamato il metodo." Finora, tutto è chiaro.

Ora rinominiamo le nostre variabili nel mainmetodo:

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.print(text);
   }

   public static void main(String[] args)
   {
     String text = "Hi";
     int count = 10;
     printLines(text, count);
   }
}

Fai attenzione a due cose

Primo: abbiamo variabili con lo stesso nome in metodi diversi. Queste sono variabili diverse (le rappresentiamo deliberatamente usando colori diversi). Tutto funziona come nell'esempio precedente, dove le variabili nel mainmetodo erano denominate stre n.

Secondo: non accade nulla di magico quando viene chiamato il metodo. Ai parametri vengono semplicemente assegnati i valori degli argomenti. Indipendentemente dal fatto che siano numeri, stringhe, variabili o espressioni.

Dopo aver rinominato le variabili nel metodo principale, non è cambiato nulla. Erano variabili diverse in metodi diversi in precedenza, e così rimangono. Non esiste una connessione magica tra le variabili text e text .

4. Passaggio di riferimenti ai metodi

Spero che tu abbia capito tutto dalla lezione precedente, perché ora rivisiteremo passando gli argomenti ai metodi, solo che ci immergeremo più a fondo.

Come già saprai, alcune variabili Java non memorizzano i valori stessi, ma invece un riferimento, ovvero l'indirizzo del blocco di memoria in cui si trovano i valori. Ecco come funzionano le variabili stringa e le variabili array.

Quando assegni un'altra variabile di matrice a una variabile di matrice, cosa succede? Giusto. Le due variabili iniziano a riferirsi allo stesso spazio in memoria:

E cosa succede se una di queste variabili è un parametro di metodo?

class Solution
{
   public static void printArraySum(int[] data)
   {
     int sum = 0;
     for (int i = 0; i < data.length; i++)
       sum = sum + data[i];
     System.out.println(sum);
   }

   public static void main(String[] args)
   {
     int[] months = {31, 28, 31, 30, 31, 30, 31, 31, 30};
     printArraySum(months);
   }
}

Succede esattamente la stessa cosa: il data parametro conterrà un riferimento alla stessa area di memoria della monthsvariabile. Quando viene chiamato il metodo, si verifica un semplice assegnamento: .data = months

E poiché entrambe le variabili si riferiscono alla stessa area di memoria che memorizza un numero intero, il printArraySum metodo non solo può leggere i valori dall'array, ma anche modificarli!

Ad esempio, possiamo scrivere il nostro metodo che riempie un array bidimensionale con lo stesso valore. Ecco come potrebbe apparire:

class Solution
{
   public static void fill(int[][] data, int value)
   {
     for (int i = 0; i < data.length; i++)
     {
       for (int j = 0; j < data[i].length; j++)
         data[i][j] = value;
     }
  }

   public static void main(String[] args)
   {
     int[][] months = {{31, 28}, {31, 30, 31}, {30, 31, 31}};
     fill (months, 8);
   }
}

5. Metodi con lo stesso nome

Ora torniamo ancora una volta ai nomi dei metodi.

Gli standard Java richiedono che tutti i metodi nella stessa classe abbiano nomi univoci. In altre parole, è impossibile dichiarare due metodi con nomi identici nella stessa classe.

Quando i metodi vengono confrontati per verificarne l'uguaglianza, non vengono presi in considerazione solo i nomi, ma anche i tipi di parametri ! Si noti che i nomi dei parametri non vengono presi in considerazione . Esempi:

void fill(int[] data, int value) {
}
void fill(int[][] data, int value) {
}
void fill(int[][][] data, int value)  {
}

void print(String str) {
}
void print(String str, String str2) {
}
void print(int val) {
}
void print(double val) {
}
void print() {
}

void sum(int x, int y) {
}
void sum(int data, int value) {
}

Perché alcuni metodi sono considerati uguali , mentre altri sono diversi ? E perché i nomi dei parametri non vengono presi in considerazione quando si determina l'unicità di un metodo?

Perché l'unicità è assolutamente necessaria? Il fatto è che quando il compilatore compila un programma, deve sapere esattamente quale metodo intendi chiamare in un dato punto.

Ad esempio, se scrivi , il compilatore è intelligente e concluderà facilmente che intendi chiamare il metodo qui con un parametro.System.out.println("Hi")println()String

Ma se scrivi , il compilatore vedrà una chiamata al metodo con un parametro.System.out.println(1.0)println()double

Quando viene chiamato un metodo, il compilatore garantisce che i tipi degli argomenti corrispondano ai tipi dei parametri. Non presta alcuna attenzione al nome degli argomenti. In Java, i nomi dei parametri non aiutano il compilatore a determinare quale metodo chiamare. Ed è per questo che non vengono presi in considerazione quando si determina l'unicità di un metodo.

Il nome di un metodo ei tipi dei suoi parametri sono chiamati firma del metodo . Per esempio,sum(int, int)

Ogni classe deve avere metodi con firme univoche anziché metodi con nomi univoci.