Parámetros de métodos en Java: argumentos, paso por valor y retorno

Los parámetros permiten que un método reciba entrada

Un método que siempre hace lo mismo es limitado. Los parámetros son las entradas que declaras dentro de los paréntesis del método para que el mismo método pueda trabajar con valores distintos cada vez que lo llamas.

Enumeras cada parámetro con un tipo y un nombre. Dentro del cuerpo del método, un parámetro se comporta como una variable local ordinaria que ya contiene lo que pasó quien llama.

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

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

name es el parámetro. "Sam" y "Alex" son los argumentos: los valores concretos suministrados en la llamada. Una sola definición de método, dos salidas diferentes.

Parámetros frente a argumentos

Estas dos palabras se usan de forma laxa, pero merece la pena tener clara la distinción:

• Un parámetro es el marcador de posición en la declaración: String name.
• Un argumento es el valor que realmente pasas: "Sam".

Así que void greet(String name) declara un parámetro, y greet("Sam") pasa un argumento. Cuando alguien dice "este método recibe dos parámetros", se refiere a la declaración; "pasé dos argumentos" se refiere a la llamada.

Múltiples parámetros

Separa los parámetros con comas y dale a cada uno su propio tipo: no puedes compartir un tipo entre dos parámetros como quizá harías en una declaración de variables:

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

Los argumentos se emparejan con los parámetros estrictamente por posición, no por nombre. describe("Sam", 30, true) funciona porque el orden coincide con (String name, int age, boolean active). Intercambia dos argumentos de tipos compatibles y obtendrás un error de lógica silencioso, no un error de compilación, así que el orden importa.

Un error frecuente es escribir int add(int a, b). Cada parámetro necesita su propio tipo: int add(int a, int b).

Devolver un valor

Los parámetros son la forma en que los datos fluyen hacia dentro; el valor de retorno es la forma en que un resultado fluye hacia fuera. Declara el tipo de retorno antes del nombre del método y usa return para devolver un valor a quien llama:

public class Main {
    static double average(int a, int b, int c) {
        int sum = a + b + c;
        return sum / 3.0;   // 3.0 fuerza la división en punto flotante
    }

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

El tipo de retorno (double) debe coincidir con lo que realmente return. Un método declarado void no devuelve nada; aún puede usar un return; sin valor para salir antes de tiempo, pero no puede devolver un valor. En el momento en que se ejecuta return, el método termina y el control salta de vuelta al punto de la llamada.

Java es paso por valor

Esto confunde a casi todo el mundo al principio. Cuando pasas un argumento, Java copia el valor dentro del parámetro. Para los primitivos, eso significa que el método obtiene su propia copia: cambiar el parámetro nunca toca la variable de quien llama:

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

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

x se mantiene en 5. El método modificó su propia copia del número, no el original.

Pasar objetos: sigue siendo por valor, pero vigila la referencia

Los objetos parecen una excepción, pero no lo son. Lo que se copia es la referencia (la flecha que apunta al objeto), no el objeto en sí. Así que el método apunta al mismo objeto y puede mutarlo:

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

public class Main {
    static void addItem(List<String> items) {
        items.add("new");        // muta el objeto compartido - visible para quien llama
    }

    static void replace(List<String> items) {
        items = new ArrayList<>();   // reasigna solo la copia local - NO visible
        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);   // sigue siendo [a, b, new] - la reasignación no escapó
    }
}

Dos resultados diferentes, una sola regla. addItem sigue la referencia y cambia la lista real, así que quien llama ve aparecer new. replace reasigna el parámetro a una lista totalmente nueva, pero eso solo reapunta la copia local de la referencia, así que la list de quien llama queda intacta. La conclusión: puedes cambiar un objeto a través de un parámetro, pero nunca puedes hacer que la variable de quien llama apunte a otro lugar.

Siguiente: sobrecarga de métodos

Ahora sabes cómo darle a un método exactamente las entradas que necesita. Pero ¿qué pasa si quieres que un mismo nombre de método acepte conjuntos distintos de parámetros, por ejemplo print(int) y print(String)? Eso es la sobrecarga de métodos, y es la página siguiente.