Parámetros en Java

Escribe un método llamado greet que reciba una palabra. Dentro de los paréntesis escribe String name. En el cuerpo imprime hi, un espacio y luego name: System.out.println("hi " + name);. Desde main llama greet("lena");. La pantalla debe mostrar una línea: hi lena. Las letras lena no están fijas dentro del método. Llegan por la llamada y se sientan en el nombre name para ese paso. Esa entrega es lo que enseña esta página.

Un nombre dentro de los paréntesis

En la página de métodos los paréntesis después de ring quedaron vacíos. La impresión era siempre ding. Aquí los paréntesis guardan un nombre tipado para que cada llamada pueda enviar un valor distinto. Ese nombre tipado es un parámetro. El valor que escribes en la llamada es el argumento de ese paso.
Crea un archivo de programa pequeño llamado Tip.java. El public class de la primera línea debe coincidir con el nombre del archivo: public class Tip. No dejes un nombre de clase antiguo como Chime o Pack en este archivo; el compilador espera que el nombre de la clase y el del archivo coincidan.
Fuera de main, todavía dentro de las llaves de la clase, escribe:
static void greet(String name) {
System.out.println("hi " + name);
}
La cabecera en esta forma de principiante sigue empezando con static void. Entre los paréntesis van primero String y luego name — el tipo primero, después el nombre del parámetro. El cuerpo usa name sin comillas alrededor, unido al texto fijo "hi " con un más. Las comillas alrededor de "hi " marcan las letras fijas. El name sin comillas marca el valor que llegó de la llamada. Guarda el archivo antes de compilar.

Tip.java con greet

Esta es la versión que compilas primero. main guarda la llamada con un valor dentro de los paréntesis. greet guarda la impresión que usa ese valor.

Desde la carpeta que contiene Tip.java ejecuta javac Tip.java. Cuando coinciden paréntesis, llaves y puntos y coma, javac no escribe ninguna línea propia. Luego ejecuta java Tip — no java Tip.java. Quita el final .java del segundo comando. Los mismos dos comandos sirven en Windows y en macOS; esta página no necesita otra ortografía de shell para ninguno de los dos sistemas. El programa debe imprimir una línea y parar: hi lena. No debe pedirte que escribas. Si la terminal espera entrada del teclado, todavía hay una llamada nextLine de un ejercicio anterior en el archivo. Borra esa llamada y conserva greet("lena"); más el método greet de arriba. Una línea incorrecta en pantalla no significa que necesites instalar de nuevo el JDK.

Recorre una ejecución completa en orden. Java empieza en main. La llamada greet("lena"); envía el texto lena al parámetro name. Dentro de greet, println construye hi, un espacio y luego ese valor, así que la pantalla muestra hi lena. Luego greet termina y main termina. No escribiste System.out.println("hi lena"); dentro de main. Escribiste la parte fija una vez bajo greet y pasaste lena desde la llamada.

El mismo método, palabras distintas

Cambia solo main para que llame a greet dos veces con dos argumentos distintos:
public static void main(String[] args) {
greet("lena");
greet("sam");
}
Deja el método greet tal cual. Compila y ejecuta otra vez: javac Tip.java, luego java Tip. La pantalla debe mostrar dos líneas: hi lena, luego hi sam. La primera llamada llena name con lena. La segunda llamada llena name con sam. No copiaste el println bajo greet. Solo cambiaste los valores dentro de las llamadas.
Si llamas greet() con paréntesis vacíos mientras la cabecera sigue diciendo String name, javac escribe un error — la llamada debe suministrar un String. Si dejas un ring(); antiguo con paréntesis vacíos de la página Chime en el mismo main, esa llamada no coincide con greet, y un método ring sobrante puede seguir imprimiendo ding junto a tus líneas hi. Limpia main hasta las llamadas greet que esta lección necesita.

Un número entero como valor

Los parámetros no son solo para texto. Escribe un segundo método que tome un int:
static void show(int n) {
System.out.println(n);
}
Llámalo desde main con números enteros:
show(9);
show(4);

Compila y ejecuta: javac Tip.java, luego java Tip. La pantalla debe mostrar dos líneas: 9, luego 4. No pongas comillas alrededor de 9 o 4 en la llamada — son valores int, no texto. Dentro de show, println(n) escribe el número que llegó. Cuando hayas visto esas dos líneas, puedes volver a poner la demo de greet. Ambas versiones son Java válido. Enseñan la misma idea: la llamada envía un valor, el parámetro lo guarda para el cuerpo.
Lee otra vez la ejecución con int. La primera llamada pone n en 9 e imprime 9. La segunda llamada pone n en 4 e imprime 4. El nombre n se declara una vez en la cabecera como int n. Cada llamada le da un valor nuevo para ese paso. Pasar una palabra entre comillas a show, como show("nine");, no coincide con int en esta forma — javac escribe un error. Pasar un número sin comillas a greet, como greet(3);, no coincide con String — javac escribe un error otra vez. Haz coincidir el tipo del argumento con el tipo del parámetro.

Una confusión común es imprimir el nombre del parámetro como texto: System.out.println("name");. Eso escribe las letras n-a-m-e. No escribe lena. Mantén println("hi " + name) sin comillas alrededor de name cuando quieras las letras del argumento en pantalla. Otra confusión es declarar el parámetro en main en lugar de en la cabecera del método. El nombre tipado pertenece dentro de greet(...) o show(...), no dentro de los paréntesis de main en esta página. String[] args de main es otro tema para una sesión posterior; no renombres args a name y esperes que greet lo vea.

Dónde te deja esta página

Puedes poner String name o int n dentro de los paréntesis de un método, pasar un valor coincidente en la llamada e imprimir ese valor desde el cuerpo. Dos llamadas con dos argumentos imprimen dos líneas distintas sin copiar el método. void sigue significando que nada vuelve por la llamada. La página siguiente es return; allí un método devuelve un valor a main en lugar de solo imprimir dentro del cuerpo.