Métodos en Java

Un método en Java es un bloque de código con nombre que puedes llamar desde cualquier otro lugar del programa. Los métodos son la forma de evitar la repetición: en lugar de escribir el mismo cálculo o la misma operación de cinco líneas en tres lugares, lo colocas en un método y lo llamas tres veces.

Ya has visto un método en cada página de este libro — main. Todo programa Java no es más que una clase con al menos un método que la JVM sabe cómo iniciar. En esta parte del libro veremos cómo escribir los tuyos propios.

Anatomía de un método

Una declaración de método tiene hasta cinco partes: modificadores, un tipo de retorno, un nombre, una lista de parámetros y un cuerpo.

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

• public static — modificadores. public controla la visibilidad; static significa que el método pertenece a la clase y no a una instancia. Profundizaremos en ambos en partes posteriores; por ahora, cada método que escribas en una clase utilitaria de nivel superior será public static.
• int — el tipo de retorno. El tipo de valor que el método devuelve a quien lo llama. Usa void si no devuelve nada.
• square — el nombre. Convencionalmente en lowerCamelCase, y un verbo o frase verbal que describe lo que hace el método.
• (int n) — la lista de parámetros. Las entradas que el llamador debe suministrar. Cada parámetro es un tipo y un nombre.
• { ... } — el cuerpo. El código que se ejecuta cuando se llama al método.

Llamar a un método

Una vez definido, llamas a un método escribiendo su nombre seguido de (...) con los valores de los argumentos:

int result = square(7);   // result is 49
System.out.println(square(3) + square(4));   // 9 + 16 = 25

El valor que devuelve el método puede usarse como cualquier otra expresión — asignado a una variable, pasado como argumento, impreso, sumado a otra cosa.

La sentencia return

return hace dos cosas: detiene el método de inmediato y envía un valor de vuelta al llamador.

public static int absolute(int n) {
  if (n < 0) {
    return -n;
  }
  return n;
}

Una vez que se ejecuta return -n, el método termina — el segundo return n no se ejecuta. Un método con un tipo de retorno que no sea void debe devolver un valor en cada posible ruta de código; el compilador se niega a compilar si falta alguna ruta.

Para los métodos void, puedes usar un return; simple para salir anticipadamente, pero no es obligatorio escribirlo al final:

public static void greet(String name) {
  if (name == null) return;          // early exit
  System.out.println("Hello, " + name);
}                                    // implicit return at the closing brace

Parámetros y argumentos

Los nombres en la firma del método son parámetros; los valores que pasas en el punto de llamada son argumentos. La distinción es pequeña pero vale la pena precisarla:

public static int sum(int a, int b) {   // a, b are parameters
  return a + b;
}

int x = 3, y = 4;
int total = sum(x, y);                   // x, y are arguments

Cada llamada obtiene sus propias copias nuevas de los parámetros. Asignar a a dentro de sum no cambia x en el punto de llamada. El capítulo sobre paso por valor profundiza en los detalles.

Reglas del tipo de retorno

La expresión después de return debe ser compatible en asignación con el tipo de retorno declarado — el mismo tipo, o un tipo que Java pueda ampliar hacia él:

public static double half(int n) {
  return n / 2.0;       // int / double → double, fine
}

public static int half(int n) {
  return n / 2.0;       // ERROR: double cannot be implicitly narrowed to int
}

Si realmente necesitas reducir el tipo, hazlo con una conversión explícita: return (int)(n / 2.0);.

Los métodos pueden llamar a otros métodos

El cuerpo de un método es código normal — incluyendo llamadas a otros métodos, incluso a sí mismo (ver recursión):

public static int square(int n)   { return n * n; }
public static int sumOfSquares(int a, int b) {
  return square(a) + square(b);
}

Construir métodos pequeños con un único propósito y componerlos es el corazón de escribir Java legible.

Retornar no es imprimir

Una confusión frecuente entre principiantes: un método que imprime un valor y uno que lo retorna no son intercambiables. return devuelve un valor al llamador para que pueda usarlo; System.out.println solo escribe texto en la consola y el llamador no recibe nada.

public static void printSquare(int n) {
  System.out.println(n * n);   // shows the result, returns void
}

public static int square(int n) {
  return n * n;                // gives the result back to the caller
}

Puedes almacenar, sumar o pasar el resultado de square, pero int x = printSquare(5); no compilará — printSquare retorna void. Prefiere retornar un valor y deja que el llamador decida si imprimirlo; eso mantiene el método reutilizable.

Sobrecarga: mismo nombre, diferentes parámetros

Java permite que dos o más métodos compartan un nombre siempre que sus listas de parámetros difieran — en el número de parámetros o en sus tipos. Esto se llama sobrecarga, y el compilador elige el correcto según los argumentos que pasas:

public static int max(int a, int b)          { return a > b ? a : b; }
public static double max(double a, double b)  { return a > b ? a : b; }
public static int max(int a, int b, int c)    { return max(max(a, b), c); }

max(3, 9) llama al primero, max(2.5, 1.5) al segundo, y max(4, 1, 7) al tercero. El tipo de retorno solo no es suficiente para distinguir sobrecargas — solo cuentan los parámetros. El capítulo de sobrecarga de métodos cubre las reglas de coincidencia en detalle.

Dónde viven los métodos

Un método siempre vive dentro de una clase. No puedes escribir una función de nivel superior como en JavaScript o Python. La clase es el contenedor; el método es uno de sus miembros. Así, un archivo completo con dos métodos tiene este aspecto:

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

  public static int cube(int n) {
    return n * n * n;
  }
}

Desde main en la misma clase, los llamarías como square(5) y cube(2). Desde una clase diferente, los calificarías: MathUtils.square(5).

Un ejemplo resuelto

Qué sigue

Ahora que puedes declarar y llamar un método, la siguiente pregunta es cómo fluyen los datos hacia él. El capítulo de parámetros repasa los detalles — cómo se alinean los argumentos con los parámetros, qué tipos están permitidos y qué ocurre cuando el llamador pasa objetos frente a primitivos.

Práctica