Parametri dei metodi in Java: argomenti, passaggio per valore e return

I parametri permettono a un metodo di ricevere input

Un metodo che fa sempre la stessa cosa è limitato. I parametri sono gli input che dichiari tra le parentesi del metodo, così lo stesso metodo può lavorare su valori diversi ogni volta che lo chiami.

Indichi ogni parametro con un tipo e un nome. Nel corpo del metodo, un parametro si comporta come una normale variabile locale che contiene già il valore passato dal chiamante.

public class Main {
    static void greet(String name) {
        System.out.println("Hello, " + name + "!");
    }

    public static void main(String[] args) {
        greet("Sam");
        greet("Alex");
    }
}

name è il parametro. "Sam" e "Alex" sono gli argomenti, cioè i valori concreti forniti nella chiamata. Una sola definizione del metodo, due output diversi.

Parametri e argomenti

Queste due parole vengono spesso usate in modo impreciso, ma vale la pena tenerle distinte:

• Un parametro è il segnaposto nella dichiarazione: String name.
• Un argomento è il valore che passi davvero: "Sam".

Quindi void greet(String name) dichiara un parametro e greet("Sam") passa un argomento. Quando qualcuno dice "questo metodo accetta due parametri" si riferisce alla dichiarazione; "ho passato due argomenti" si riferisce alla chiamata.

Più parametri

Separa i parametri con le virgole e dai a ciascuno il proprio tipo: non puoi condividere un tipo tra due parametri come faresti in una dichiarazione di variabili:

public class Main {
    static int add(int a, int b) {
        return a + b;
    }

    static String describe(String name, int age, boolean active) {
        return name + " (" + age + ", " + (active ? "active" : "inactive") + ")";
    }

    public static void main(String[] args) {
        System.out.println(add(2, 3));
        System.out.println(describe("Sam", 30, true));
    }
}

Gli argomenti vengono associati ai parametri solo in base alla posizione, non al nome. describe("Sam", 30, true) funziona perché l'ordine corrisponde a (String name, int age, boolean active). Se scambi due argomenti di tipi compatibili ottieni un bug logico silenzioso, non un errore di compilazione: l'ordine conta.

Un errore comune è scrivere int add(int a, b). Ogni parametro ha bisogno del suo tipo: int add(int a, int b).

Restituire un valore

I parametri sono il modo in cui i dati entrano; il valore di ritorno è il modo in cui un risultato torna fuori. Dichiara il tipo di ritorno prima del nome del metodo e usa return per restituire un valore al chiamante:

public class Main {
    static double average(int a, int b, int c) {
        int sum = a + b + c;
        return sum / 3.0;   // 3.0 forza la divisione in virgola mobile
    }

    public static void main(String[] args) {
        double result = average(4, 5, 9);
        System.out.println("Average: " + result);
    }
}

Il tipo di ritorno (double) deve corrispondere a ciò che restituisci davvero con return. Un metodo dichiarato void non restituisce niente: può comunque usare un semplice return; per uscire prima, ma non può restituire un valore. Nel momento in cui return viene eseguito, il metodo termina e il controllo torna al punto della chiamata.

Java passa per valore

All'inizio questo confonde quasi tutti. Quando passi un argomento, Java copia il valore nel parametro. Per i tipi primitivi significa che il metodo riceve una sua copia: modificare il parametro non tocca mai la variabile del chiamante:

public class Main {
    static void tryToChange(int n) {
        n = 999;   // cambia solo questa copia locale
    }

    public static void main(String[] args) {
        int x = 5;
        tryToChange(x);
        System.out.println(x);   // ancora 5
    }
}

x resta 5. Il metodo ha modificato la propria copia del numero, non l'originale.

Passare oggetti: sempre per valore, ma attento al riferimento

Gli oggetti sembrano un'eccezione, ma non lo sono. Ciò che viene copiato è il riferimento (la freccia che punta all'oggetto), non l'oggetto stesso. Quindi il metodo punta allo stesso oggetto e può modificarlo: è proprio per questo che aggiungere elementi a un ArrayList condiviso dentro un metodo è visibile al chiamante:

import java.util.ArrayList;
import java.util.List;

public class Main {
    static void addItem(List<String> items) {
        items.add("new");        // modifica l'oggetto condiviso: visibile al chiamante
    }

    static void replace(List<String> items) {
        items = new ArrayList<>();   // riassegna solo la copia locale: NON visibile
        items.add("ignored");
    }

    public static void main(String[] args) {
        List<String> list = new ArrayList<>(List.of("a", "b"));

        addItem(list);
        System.out.println(list);   // [a, b, new]

        replace(list);
        System.out.println(list);   // ancora [a, b, new]: la riassegnazione non è uscita dal metodo
    }
}

Due risultati diversi, una sola regola. addItem segue il riferimento e modifica la lista vera, quindi il chiamante vede comparire new. replace riassegna il parametro a una lista completamente nuova, ma così cambia solo la copia locale del riferimento, e la list del chiamante resta intatta. In sintesi: puoi modificare un oggetto tramite un parametro, ma non puoi mai far puntare la variabile del chiamante a qualcos'altro.

Prossima pagina: overloading dei metodi

Ora sai come passare a un metodo esattamente gli input di cui ha bisogno. Ma se volessi che un solo nome di metodo accettasse insiemi diversi di parametri, per esempio print(int) e print(String)? Si chiama overloading dei metodi ed è l'argomento della prossima pagina.