TutorJava Nivel Básico: tutorial completo Java 21

Los métodos son bloques de código reutilizables. En Java 21, la combinación de métodos tradicionales con lambdas y referencias a métodos ofrece una herramienta muy expresiva.

Declaración de métodos

// Sintaxis: modificadores tipoRetorno nombre(parámetros)
public static int sumar(int a, int b) {
    return a + b;
}

// Método void (sin retorno)
public void imprimir(String mensaje) {
    System.out.println(mensaje);
}

// Método que devuelve un objeto
public List obtenerNombres() {
    return List.of("Ana", "Luis", "Pedro");
}

Sobrecarga de métodos

Varios métodos pueden tener el mismo nombre si difieren en la lista de parámetros (número, tipo u orden). El compilador elige el método correcto en cada llamada:

public class Calculadora {
    public int sumar(int a, int b) { return a + b; }
    public double sumar(double a, double b) { return a + b; }
    public int sumar(int a, int b, int c) { return a + b + c; }
    public String sumar(String a, String b) { return a + b; }
}

Calculadora calc = new Calculadora();
calc.sumar(1, 2);           // int
calc.sumar(1.5, 2.5);       // double
calc.sumar("Hola", " Java"); // String

Varargs: número variable de argumentos

Los varargs permiten pasar cero o más argumentos del mismo tipo. Deben ser el último parámetro:

public static int sumarTodos(int... numeros) {
    int total = 0;
    for (int n : numeros) {
        total += n;
    }
    return total;
}

sumarTodos();             // 0
sumarTodos(1, 2, 3);      // 6
sumarTodos(1, 2, 3, 4, 5); // 15

Paso de parámetros: por valor siempre

En Java, los parámetros siempre se pasan por valor. Para primitivos, el método recibe una copia del valor. Para objetos, el método recibe una copia de la referencia (puede modificar el objeto referenciado, pero no reasignar la variable del llamador):

public static void duplicar(int n) {
    n = n * 2;  // solo modifica la copia local
}

public static void limpiarLista(List lista) {
    lista.clear();  // modifica el objeto referenciado
    // lista = new ArrayList<>();  esto NO afectaría a la variable del llamador
}

int x = 5;
duplicar(x);
System.out.println(x);  // 5, no cambió

List nombres = new ArrayList<>(List.of("Ana", "Luis"));
limpiarLista(nombres);
System.out.println(nombres.size());  // 0, el objeto fue modificado

Métodos estáticos vs. de instancia

Los métodos estáticos (static) no necesitan una instancia. Los métodos de instancia operan sobre el estado del objeto. Regla: si el método no accede a ningún atributo de instancia (this), considera hacerlo estático (o moverlo a una clase de utilidades).

Referencias a métodos (Java 8+)

Las referencias a métodos son una forma concisa de pasar métodos como argumentos donde se espera una interfaz funcional:

List nombres = List.of("Carlos", "Ana", "Pedro", "Beatriz");

// Lambda
nombres.stream().forEach(n -> System.out.println(n));

// Referencia a método (equivalente)
nombres.stream().forEach(System.out::println);

// Referencia a método estático
List nums = List.of("3", "1", "4", "1", "5");
nums.stream()
    .map(Integer::parseInt)
    .sorted()
    .forEach(System.out::println);

// Referencia a método de instancia de un objeto concreto
String prefijo = "Hola, ";
nombres.stream()
    .map(prefijo::concat)
    .forEach(System.out::println);