Metodi in Java: come definire e chiamare un metodo

Perché esistono i metodi

Un metodo è un blocco di codice con un nome che puoi eseguire ogni volta che lo chiami. Invece di scrivere le stesse righe più e più volte, le scrivi una volta dentro un metodo e lo chiami tutte le volte che ti serve. Così i programmi sono più corti, più facili da leggere e molto più facili da correggere: cambi la logica in un punto e ogni chiamata riceve l'aggiornamento.

Hai già chiamato dei metodi: System.out.println(...) è una chiamata a un metodo, e lo è anche list.size(). Ora scriverai i tuoi.

Dichiarare e chiamare un metodo

La dichiarazione di un metodo ha quattro parti: un tipo di ritorno, un nome, una coppia di parentesi (per i parametri) e un corpo tra graffe. Ecco l'esempio utile più piccolo possibile, un metodo che fa qualcosa e non restituisce niente:

public class Main {
    static void printGreeting() {
        System.out.println("Hello from a method!");
    }

    public static void main(String[] args) {
        printGreeting();   // chiamalo
        printGreeting();   // chiamalo di nuovo
    }
}

Guarda i pezzi di static void printGreeting():

• static: permette a main di chiamarlo direttamente senza creare un oggetto (ne parliamo più avanti).
• void: questo metodo non restituisce alcun valore.
• printGreeting: il nome che usi per chiamarlo.
• (): le parentesi vuote indicano che non riceve input.

Chiami un metodo scrivendo il suo nome seguito dalle parentesi. Le due chiamate in main eseguono il corpo due volte, quindi il saluto viene stampato due volte.

Restituire un valore

La maggior parte dei metodi calcola qualcosa e lo restituisce con return. Il tipo di ritorno prima del nome indica quale tipo di dato esce; qui, int:

public class Main {
    static int square(int n) {
        return n * n;
    }

    public static void main(String[] args) {
        int result = square(5);
        System.out.println(result);          // 25
        System.out.println(square(3) + 1);   // 10
    }
}

square(5) vale 25, che puoi salvare in una variabile, stampare o usare in un'espressione più grande: una chiamata a un metodo sta al posto del valore che restituisce. Nel momento in cui return viene eseguito, il metodo termina e il controllo torna al chiamante. Il codice che si trova dopo un return sullo stesso percorso non viene mai eseguito.

Il tipo di ritorno e il valore restituito devono corrispondere: il tipo che dichiari è il tipo di valore che il metodo promette di restituire. Dichiarare int e provare a fare return "text"; è un errore di compilazione: il compilatore fa rispettare il patto.

void o un tipo di ritorno

La scelta è semplice: usa un vero tipo di ritorno quando il chiamante ha bisogno di un valore, e void quando il metodo si limita a fare qualcosa (stampare, salvare, aggiornare lo stato).

void logMessage(String msg)   // fa il suo lavoro, non restituisce niente
int  add(int a, int b)        // calcola un valore usato dal chiamante

Un errore comune per chi inizia è provare a usare il "risultato" di un metodo void:

int x = printGreeting();   // errore di compilazione: printGreeting() restituisce void

Non c'è nessun valore da assegnare, quindi il codice non compila. Se ti ritrovi a volere il risultato di un metodo void, è segno che dovrebbe restituire qualcosa.

Metodi con più rami e return anticipati

Puoi usare return in più punti. Uscire subito, appena conosci la risposta, spesso si legge meglio che annidare tutto in un else:

public class Main {
    static String grade(int score) {
        if (score >= 90) return "A";
        if (score >= 80) return "B";
        if (score >= 70) return "C";
        return "F";
    }

    public static void main(String[] args) {
        System.out.println(grade(95));   // A
        System.out.println(grade(72));   // C
        System.out.println(grade(50));   // F
    }
}

Poiché ogni return esce immediatamente, vince la prima condizione vera. Assicurati solo che ogni percorso di un metodo che restituisce un valore finisca con un return: se un ramo può arrivare in fondo senza restituire niente, il compilatore si lamenta con "missing return statement". Qui il return "F"; finale copre questo caso.

Cosa significa static qui

Forse hai notato che tutti i metodi qui sopra sono static. Un metodo static appartiene alla classe stessa, non a un oggetto, quindi main (anche lui static) può chiamarlo direttamente per nome. Senza static, il metodo appartiene a un'istanza e ti servirebbe un oggetto su cui chiamarlo.

Per ora, mentre scrivi piccoli programmi con la logica accanto a main, dichiara static i tuoi metodi di supporto così puoi chiamarli allo stesso modo. Quando inizierai a creare le tue classi e i tuoi oggetti, scriverai anche metodi non statici (di istanza): arriveranno con il capitolo sulle classi.

public class Main {
    static int doubleIt(int n) {
        return n * 2;
    }

    public static void main(String[] args) {
        // main è static, quindi può chiamare doubleIt direttamente
        System.out.println(doubleIt(21));   // 42
    }
}

Le variabili locali restano dentro il metodo

Le variabili dichiarate dentro un metodo esistono solo lì. Vengono create quando il metodo viene eseguito e spariscono quando restituisce il controllo: il chiamante non le vede mai:

public class Main {
    static int sumTo(int limit) {
        int total = 0;                       // locale a sumTo
        for (int i = 1; i <= limit; i++) {
            total += i;
        }
        return total;
    }

    public static void main(String[] args) {
        System.out.println(sumTo(100));      // 5050
        // System.out.println(total);        // errore: total non è visibile qui
    }
}

total e i vivono interamente dentro sumTo. L'unica cosa che esce dal metodo è il valore che restituisci con return. Questo isolamento è un vantaggio: ogni metodo è un'unità a sé su cui puoi ragionare senza preoccuparti che le sue variabili temporanee escano fuori o entrino in conflitto con nomi usati altrove.

Prossima pagina: parametri dei metodi

Ogni metodo qui non riceveva input oppure riceveva un solo valore. La vera potenza arriva quando passi dati in ingresso, e Java ha regole precise su come vengono passati gli argomenti, cosa succede con gli oggetti rispetto ai tipi primitivi e come dare a un parametro un valore di ripiego simile a un default. È l'argomento della prossima pagina.