Parametri di metodo in Java

"Ciao Amigo! Spero che ti sia piaciuto risolvere i compiti usando i tuoi metodi e che ti rendi conto di quanto sia conveniente creare metodi. Ora parliamo dell'argomento più interessante di tutti."

"Hai stuzzicato il mio interesse, Diego... Un nuovo argomento?"

"Ogni argomento è nuovo per te, mio ​​giovane robot! E questo non fa eccezione. Anche se ancora una volta si tratta di metodi. Probabilmente avrai già notato che da metodi del genere possiamo passare argomenti a metodi. Una volta che siamo dentro il System.out.println()metodo , li chiamiamo parametri."

"I parametri sono ciò che scriviamo tra parentesi?"

"Sì, esatto. E, in effetti, i parametri migliorano notevolmente i vantaggi che otteniamo dalla creazione e dall'utilizzo di metodi."

"Capisco cosa stai dicendo sull'uso di loro, e si scopre che l'ho già fatto. Come dichiariamo un metodo con parametri?"

"In realtà è abbastanza semplice:

public static void name(parameters)
{
  method body
}

"Dov'è nameil nome univoco del metodo e method bodyrappresenta i comandi che compongono il metodo. Ed parametersè un segnaposto per i parametri del metodo, separati da virgole."

"Hmm... credo di aver capito... o forse no..."

"Lascia che ti fornisca qualche dettaglio in più su questo modello in modo da essere certo di aver compreso di aver compreso:

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

Ecco alcuni esempi:

public static void print(String str)
{
}

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

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

"Ah... Ora è chiaro. E se non vogliamo che il metodo abbia parametri, allora lasciamo vuote le parentesi."

"Esattamente. Fondamentalmente, i parametri sono variabili speciali all'interno di un metodo. Con il loro aiuto, puoi passare vari valori al metodo quando viene chiamato. E se non hai bisogno di passare valori, lascia le parentesi vuote.

"Ad esempio, scriviamo un metodo che visualizza una determinata riga di testo un determinato numero di volte. Qualche idea su come farlo?"

"Beh... Mi sembra di sapere bene come scrivere codice per visualizzare più volte una stringa sullo schermo..."

"Come si specifica la stringa da visualizzare? E come si specifica il numero di righe visualizzate? Riesci a indovinare?"

"Le cose cominciano a diventare chiare... Probabilmente con l'aiuto dei parametri del metodo?"

"Esattamente. Un parametro stringa per la riga di testo e un parametro numerico per il numero di righe visualizzate. Il codice che esegue questa operazione sarà simile al seguente:

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 a eseguire i comandi all'interno del metodo.

argomenti

"Voglio che tu presti particolare attenzione alla chiamata di metodi che hanno parametri. I valori passati al metodo sono solitamente chiamati argomenti quando vengono passati al metodo.

Diamo un'altra occhiata al nostro 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 printLinesmetodo è 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", 10e 20sono essi stessi chiamati argomenti."

"Cercherò di ricordare la differenza e di non confondere questi concetti."

Nomi di variabili in conflitto quando si chiama un metodo

"Quando chiami un metodo, puoi usare le variabili come argomenti.

"Beh, questo ha senso!"

"Ha senso, ma può potenzialmente produrre alcune difficoltà. Torniamo ancora una volta al nostro 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";
     String n = 10;
     printLines(str, n);
   }
}

"Hmm... non vedo alcuna difficoltà. Abbiamo una strvariabile. Il suo valore è assegnato al textparametro quando viene chiamato il metodo. Abbiamo una nvariabile. Il suo valore è assegnato al countparametro quando viene chiamato il metodo." "Finora, tutto è chiaro."

"Bene, bene. 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";
     String count = 10;
     printLines(text, count);
   }
}

"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. In precedenza erano variabili diverse in metodi diversi , e quindi rimangono. Non esiste una connessione magica tra le due textvariabili."

"Adesso lo so."

Passaggio di riferimenti ai metodi

"Spero che tu abbia già assimilato tutto quello che ti ho detto sul passaggio degli argomenti ai metodi. Lo dico, perché ora ci addentreremo un po' più a fondo in questo argomento. Ascolta attentamente."

"Sai già che alcune variabili in Java non memorizzano i valori stessi, ma piuttosto 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 uno sviluppatore assegna un'altra variabile di matrice a una variabile di matrice, cosa succede?"

"Indicano quindi allo stesso indirizzo?"

"Esatto. Le due variabili iniziano a fare riferimento allo stesso spazio in memoria:

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

class Solution
{
   public static void sum(int[] data)
   {
     int total = 0;
     for (int i = 0; i < data.length; i++)
       total = total + data[i];
     System.out.println(total);
   }
   
   public static void main(String[] args)
   {
     int[] months = {31, 28, 31, 30, 31, 30, 31, 31, 30};
     sum(months);
   }
}

"Succede esattamente la stessa cosa: il dataparametro 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 summetodo non solo può leggere i valori dall'array, ma anche modificarli!"

"Credo di aver capito, ma ho bisogno di altri esempi!"

"Bene, 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);
   }
}

Metodi con lo stesso nome

"Ora torniamo ancora una volta ai nomi dei metodi."

"Non riesco a immaginare cos'altro si potrebbe dire sui nomi!"

"Bene, lo standard del linguaggio Java richiede che tutti i metodi nella stessa classe abbiano nomi univoci.

"Quindi, è impossibile dichiarare due metodi con nomi identici nella stessa classe?"

"Ora, presta molta attenzione! I metodi in una classe possono effettivamente avere nomi identici! Ma in questo caso, devono avere parametri diversi. In altre parole, i metodi vengono confrontati per verificarne l'identità, non solo i nomi vengono presi in considerazione, ma anche i tipi dei parametri !Nota che ho detto specificatamente tipi .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) {
}

"Sono totalmente confuso! Perché abbiamo bisogno di tutto questo? 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à è necessaria a Tutto?"

"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. Ma se scrivi , il compilatore vedrà una chiamata al metodo con un parametro. Non ha idea quale nome il programmatore ha dato al parametro quando ha dichiarato il metodo."System.out.println("Hi")println()StringSystem.out.println(1.0)println()double

Ahh, sembra che stia iniziando a passare!

"Quando viene chiamato un metodo, il compilatore assicura 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 utilizzare call I programmatori ne hanno bisogno, non il compilatore.

"E immagino sia per questo che non vengono presi in considerazione quando si determina l'unicità di un metodo?"

"Sì, è del tutto corretto. Il nome di un metodo e i tipi dei suoi parametri sono chiamati firma del metodo . Ad esempio, sum (int, int)"

"Quindi ogni classe deve avere metodi con firme univoche piuttosto che metodi con nomi univoci."

"Ben fatto, Amigo! Hai riassunto perfettamente questa lezione. Se qualcosa rimane poco chiaro, niente panico. Questo argomento diventerà chiaro dopo un paio di compiti."