Métodos en Java

Un método en Java es un bloque de código con nombre que puede llamar desde 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 coloca en un método y lo llama tres veces.

Ya ha 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 arrancar. En esta parte del libro veremos cómo escribir los suyos 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 escriba en una clase de utilidad de nivel superior será public static.
• int — el tipo de retorno. La clase de valor que el método devuelve a quien lo llama. Use void si no devuelve nada.
• square — el nombre. Por convención en lowerCamelCase, y un verbo o frase verbal que dice qué hace el método.
• (int n) — la lista de parámetros. Las entradas que quien llama 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, llama a un método escribiendo su nombre seguido de (...) con los valores de los argumentos:

int result = square(7);   // result es 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 a quien lo llama.

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

En cuanto se ejecuta return -n, el método ha terminado — el segundo return n no se ejecuta. Un método con un tipo de retorno distinto de void debe devolver un valor en cada ruta de código posible; el compilador se niega a compilar si falta una ruta.

Para los métodos void, puede usar un simple return; para salir antes, pero no tiene que escribir uno al final:

public static void greet(String name) {
  if (name == null) return;          // salida anticipada
  System.out.println("Hello, " + name);
}                                    // return implícito en la llave de cierre

Parámetros y argumentos

Los nombres en la firma del método son parámetros; los valores que pasa en el lugar de la llamada son argumentos. La distinción es pequeña pero conviene entenderla bien:

public static int sum(int a, int b) {   // a, b son parámetros
  return a + b;
}

int x = 3, y = 4;
int total = sum(x, y);                   // x, y son argumentos

Cada llamada obtiene sus propias copias frescas de los parámetros. Asignar a a dentro de sum no cambia x en el lugar de la 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 por asignación con el tipo de retorno declarado — el mismo tipo, o un tipo al que Java pueda ampliarlo:

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

public static int half(int n) {
  return n / 2.0;       // ERROR: double no puede estrecharse implícitamente a int
}

Si realmente necesita estrechar, hace 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 no es más que código corriente — incluidas las llamadas a otros métodos, incluido él mismo (véase la 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, de propósito único, y componerlos es el corazón de escribir Java legible.

Dónde viven los métodos

Un método siempre vive dentro de una clase. No puede escribir una función de nivel superior como puede hacerlo en JavaScript o Python. La clase es el contenedor; el método es uno de sus miembros. Así que 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ía como square(5) y cube(2). Desde una clase distinta, los calificaría: MathUtils.square(5).

Un ejemplo trabajado

Qué sigue

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

Práctica