Parâmetros de métodos em Java: argumentos, passagem por valor e retorno

Parâmetros permitem que um método receba entradas

Um método que sempre faz a mesma coisa é limitado. Parâmetros são as entradas que você declara dentro dos parênteses do método para que o mesmo método possa trabalhar com valores diferentes a cada chamada.

Você lista cada parâmetro com um tipo e um nome. Dentro do corpo do método, um parâmetro se comporta como uma variável local comum que já contém o que quem chamou passou.

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

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

name é o parâmetro. "Sam" e "Alex" são os argumentos - os valores concretos fornecidos na chamada. Uma definição de método, duas saídas diferentes.

Parâmetros versus argumentos

Essas duas palavras são usadas de forma solta, mas vale a pena manter a distinção clara:

• Um parâmetro é o espaço reservado na declaração: String name.
• Um argumento é o valor que você realmente passa: "Sam".

Então void greet(String name) declara um parâmetro, e greet("Sam") passa um argumento. Quando alguém diz "este método recebe dois parâmetros", se refere à declaração; "passei dois argumentos" se refere à chamada.

Múltiplos parâmetros

Separe os parâmetros com vírgulas e dê a cada um o seu próprio tipo - você não pode compartilhar um tipo entre dois parâmetros como faria em uma declaração de variável:

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));
    }
}

Os argumentos são associados aos parâmetros estritamente por posição, não por nome. describe("Sam", 30, true) funciona porque a ordem coincide com (String name, int age, boolean active). Troque dois argumentos de tipos compatíveis e você terá um bug de lógica silencioso, não um erro de compilação - por isso a ordem importa.

Um erro comum é escrever int add(int a, b). Cada parâmetro precisa do seu próprio tipo: int add(int a, int b).

Retornando um valor

Parâmetros são como os dados fluem para dentro; o valor de retorno é como um resultado flui de volta para fora. Declare o tipo de retorno antes do nome do método e use return para devolver um valor a quem chamou:

public class Main {
    static double average(int a, int b, int c) {
        int sum = a + b + c;
        return sum / 3.0;   // 3.0 força a divisão em ponto flutuante
    }

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

O tipo de retorno (double) deve coincidir com o que você realmente faz return. Um método declarado void não retorna nada - ele ainda pode usar um return; simples para sair mais cedo, mas não pode retornar um valor. No instante em que return é executado, o método termina e o controle volta para o ponto da chamada.

Java é passagem por valor

Isso confunde quase todo mundo no início. Quando você passa um argumento, Java copia o valor para o parâmetro. Para tipos primitivos, isso significa que o método recebe sua própria cópia - alterar o parâmetro nunca toca a variável de quem chamou:

public class Main {
    static void tryToChange(int n) {
        n = 999;   // altera apenas esta cópia local
    }

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

x continua 5. O método modificou sua própria cópia do número, não o original.

Passando objetos: ainda por valor, mas atenção à referência

Objetos parecem uma exceção, mas não são. O que é copiado é a referência (a seta que aponta para o objeto), não o objeto em si. Então o método aponta para o mesmo objeto e pode mutá-lo:

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

public class Main {
    static void addItem(List<String> items) {
        items.add("new");        // muta o objeto compartilhado - visível para quem chamou
    }

    static void replace(List<String> items) {
        items = new ArrayList<>();   // reatribui apenas a cópia local - NÃO visível
        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);   // ainda [a, b, new] - a reatribuição não escapou
    }
}

Dois resultados diferentes, uma só regra. addItem segue a referência e altera a lista real, então quem chamou vê new aparecer. replace reatribui o parâmetro a uma lista totalmente nova - mas isso só reaponta a cópia local da referência, então a list de quem chamou permanece intacta. A conclusão: você pode alterar um objeto através de um parâmetro, mas nunca pode fazer a variável de quem chamou apontar para outro lugar.

Próximo: sobrecarga de métodos

Agora você sabe como fornecer a um método exatamente as entradas de que ele precisa. Mas e se você quiser que um mesmo nome de método aceite conjuntos diferentes de parâmetros - digamos print(int) e print(String)? Isso é sobrecarga de métodos, e é a próxima página.