Parámetros de métodos en Java

Los parámetros son las entradas que declara un método; los argumentos son los valores que se proporcionan al invocarlo. El compilador verifica que los argumentos coincidan con los parámetros por tipo y posición, y luego los entrega al método como variables locales que puede utilizar en su cuerpo.

Este capítulo recorre ese proceso en detalle — la sintaxis, los tipos que se pueden pasar y las reglas que Java aplica para convertir entre ellos.

Declarar parámetros

La lista de parámetros de un método es una secuencia separada por comas de pares Tipo nombre:

public static void greet(String name, int times) {
  for (int i = 0; i < times; i++) {
    System.out.println("Hello, " + name);
  }
}

Un método puede declarar cero, uno o varios parámetros. Cada uno necesita su propio tipo — no existe una forma abreviada como int a, b (eso sería int a seguido de b, lo cual no compilará).

Llamar con argumentos

En el punto de llamada, se pasan los valores en el mismo orden en que están declarados los parámetros:

greet("Ada", 3);    // name = "Ada", times = 3

El compilador verifica dos cosas:

1. Aridad — la cantidad de argumentos coincide con la cantidad de parámetros.
2. Tipos — el tipo de cada argumento es compatible con el tipo del parámetro correspondiente.

Si alguna verificación falla, el programa no compilará. Si se pasa un String donde se espera un int, se obtendrá un error como incompatible types: String cannot be converted to int.

Los parámetros son variables locales

Dentro del método, cada parámetro se comporta como una variable local que ha sido inicializada con el valor del argumento:

public static int doubleIt(int n) {
  n = n * 2;          // legal: n is just a local
  return n;
}

int x = 5;
int result = doubleIt(x);   // result is 10
System.out.println(x);       // still 5

Reasignar n dentro de doubleIt no afecta a x en el punto de llamada. Cada invocación obtiene su propia copia nueva del parámetro. Esto es lo que se quiere decir cuando se dice que Java usa "paso por valor" — cada argumento se copia en la ranura del parámetro. Los capítulos siguientes cubren las implicaciones, especialmente para argumentos de objetos.

Ampliación implícita

Java ampliará automáticamente un tipo numérico más pequeño a uno más grande para coincidir con el parámetro:

public static double half(double x) {
  return x / 2;
}

int n = 7;
double result = half(n);   // n is widened from int to double

La ampliación está permitida porque no se pierde información. El estrechamiento no es implícito — pasar un double a un parámetro int requiere una conversión explícita:

half(7.5);            // fine: double argument, double parameter
double d = 3.7;
int i = (int) d;      // explicit cast
half(i);              // also fine

Las mismas reglas de ampliación se aplican como con la asignación: byte → short → int → long → float → double, y char → int.

Parámetros de objetos

Se puede pasar cualquier objeto — String, un array, una clase personalizada — declarando un parámetro del tipo de referencia correspondiente:

public static int firstLength(String[] words) {
  if (words.length == 0) return 0;
  return words[0].length();
}

String[] colors = {"red", "green", "blue"};
System.out.println(firstLength(colors));   // 3

El argumento también puede ser null, en cuyo caso el parámetro es null y cualquier acceso a campo o llamada a método sobre él lanza NullPointerException. Los métodos que aceptan referencias suelen comprobarlo primero o documentar que null no está permitido.

Pasar null

null es compatible con todo tipo de referencia en cuanto a asignación, por lo que se puede pasar para cualquier parámetro de objeto:

greet(null, 1);

Si el método desreferencia el parámetro (name.length(), name.charAt(0), …), lanzará una excepción. Un método defensivo maneja null explícitamente, a menudo con una verificación al inicio:

public static void greet(String name, int times) {
  if (name == null) name = "stranger";
  for (int i = 0; i < times; i++) {
    System.out.println("Hello, " + name);
  }
}

Parámetros final

Se puede marcar un parámetro como final para prohibir su reasignación dentro del método:

public static int doubleIt(final int n) {
  // n = n * 2;     // ERROR: cannot assign a value to final variable n
  return n * 2;
}

Esto no cambia lo que ve el llamador — solo determina si el cuerpo puede reutilizar la ranura del parámetro. Muchas guías de estilo tratan todos los parámetros como si fueran final aunque no se use la palabra clave; simplemente se calculan nuevos valores en lugar de mutar el parámetro.

Orden de evaluación de argumentos

Cuando se escribe f(a(), b(), c()), los argumentos se evalúan de izquierda a derecha, todos antes de que se llame a f. Si a() lanza una excepción, b() y c() nunca se ejecutan.

public static int log(String label, int value) {
  System.out.println(label + " = " + value);
  return value;
}

public static int sum(int a, int b, int c) {
  return a + b + c;
}

sum(log("a", 1), log("b", 2), log("c", 3));
// prints:
//   a = 1
//   b = 2
//   c = 3

Este determinismo es diferente a C y C++; en Java el orden es fijo y predecible.

Ejemplo práctico

Qué sigue

Ya sabes cómo entran los datos a un método. A veces se quieren dos métodos con el mismo nombre pero diferentes entradas — por ejemplo, uno que acepta un int y otro que acepta un String. Java permite escribir ambos a la vez con la sobrecarga de métodos.

Práctica