Ámbito en Java

Escribe un método llamado mark con un parámetro: static void mark(int n). Dentro de las llaves imprime ese parámetro con System.out.println(n);. Desde main llama mark(4);. La pantalla debe mostrar una línea: 4. El nombre n existe solo dentro de mark. Si intentas imprimir n desde main, javac lo rechaza. Ese límite — qué nombres puede ver un método — es lo que enseña esta página.

Nombres que se quedan dentro de un método

En la página de sobrecarga, varios métodos paint compartían un nombre pero mantenían listas de parámetros separadas. Aquí el foco es más pequeño: un método, un nombre de parámetro y dónde puede aparecer ese nombre. Un parámetro es un nombre que pertenece al método que lo declara. Fuera de las llaves de ese método, el nombre desaparece.
Crea un archivo de programa pequeño llamado Gate.java. El public class de la primera línea debe coincidir con el nombre del archivo: public class Gate. No dejes un nombre de clase antiguo Sign o Box 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 mark(int n). El cuerpo tiene una impresión: System.out.println(n);. En esta página mantén void. Estás mirando la visibilidad, no los valores de retorno. Guarda el archivo antes de compilar. El primer programa completo está en el siguiente cuadro.

Gate.java con mark

Esta es la versión que compilas primero. main tiene la llamada. mark tiene la impresión que usa n.

Desde la carpeta que guarda Gate.java, ejecuta javac Gate.java. Cuando paréntesis, llaves y puntos y coma coinciden, javac no escribe una línea propia. Luego ejecuta java Gate — no java Gate.java. Quita la terminación .java del segundo comando. Los mismos dos comandos funcionan en Windows y en macOS. El programa debe imprimir una línea y parar: 4. No debe pedirte que escribas. Si la terminal espera entrada de teclado, aún queda una llamada nextLine de un ejercicio anterior. Bórrala y conserva mark(4); más el método mark de arriba.
Recorre la ejecución una vez en orden. Java empieza en main. La llamada mark(4) envía 4 al parámetro n. Dentro de mark, println(n) escribe 4. Cuando mark termina, el nombre n también termina. main nunca tuvo un nombre n. El número 4 cruzó la llamada como valor. El nombre n no se movió a main.
Si añades System.out.println(n); dentro de main después de la llamada, javac dice que no encuentra el símbolo n. Ese error es la lección: n nunca se declaró en main. Arréglalo quitando esa línea de main, o declara otro nombre en main si necesitas un local allí. No esperes que el parámetro de mark aparezca solo en main.

Un nombre local junto al parámetro

Dentro de mark también puedes declarar un nombre nuevo que no sea parámetro. Ese nombre local vive solo entre las llaves de mark. Cambia el cuerpo para guardar una etiqueta e imprimir la etiqueta y n en una línea, o guarda un segundo método corto para la demo — en esta página el siguiente cuadro muestra en su lugar pasar un nombre desde main, el camino habitual del principiante.
Una esperanza frecuente del principiante es que un nombre declarado en main sea visible automáticamente en todos los métodos de la clase. En esta forma, no lo es. Si main tiene int room = 4; y mark intenta imprimir room sin recibirlo, javac no encuentra room dentro de mark. La solución es pasar el valor: mark(room); con mark declarado aún como mark(int n).

Pasa un local de main a mark

Declara int room = 4; dentro de main. Llama mark(room);. Dentro de mark, sigue imprimiendo n. La pantalla sigue mostrando 4. El nombre local en main es room. El nombre del parámetro en mark es n. Son nombres distintos en sitios distintos. El valor 4 es lo que viaja.

Compila y ejecuta otra vez: javac Gate.java, luego java Gate. Sigues viendo una línea: 4. Si cambias room a 9 y dejas el cuerpo del método, la pantalla muestra 9. El método sigue imprimiendo el valor que llegó en n. main también puede imprimir room si añades System.out.println(room); en main — ese nombre pertenece allí. main sigue sin poder imprimir n.
Si mark declara su propio local — por ejemplo int tag = 1; dentro de las llaves — ese tag es invisible para main. Intentar System.out.println(tag); en main falla por la misma razón que imprimir n desde main. Las llaves de mark son un muro para los nombres declarados dentro.

Qué protege el muro

Lee la separación con palabras claras. Los nombres declarados en main se quedan en main salvo que pases sus valores en una llamada. Los nombres declarados en mark — parámetros y locales — se quedan en mark. La llamada lleva valores, no los nombres mismos. La sobrecarga de la página anterior es otra habilidad: varios métodos con un mismo nombre de método. El ámbito trata de dónde puede aparecer un nombre de variable o parámetro en el código fuente.
Una demo sobrante de Sign con varios métodos paint puede quedarse en el mismo archivo y confundir la pantalla si main aún llama paint("ok"). Deja main solo con la llamada mark que estás probando. No anides mark dentro de las llaves de main. Los métodos van dentro de la clase, junto a main.
Escribir System.out.println("n"); en main imprime la letra n entre comillas. No imprime el parámetro. Conserva println(n) dentro de mark cuando quieras el valor que llegó por la llamada. Escribir mark(); con paréntesis vacíos falla si el encabezado sigue diciendo mark(int n) — la llamada debe enviar un int, sea un literal como 4 o un local como room.

Antes de recursion

Puedes escribir mark(int n), imprimir n dentro de ese método y mantener n fuera de main. Puedes declarar room en main y pasar room a mark. La pantalla muestra el valor que cruzó la llamada. Los nombres no se filtran solos por las llaves. La página siguiente es recursion, donde un método se llama a sí mismo con un argumento más pequeño hasta que una condición de parada termina la cadena.