Escopo em Java

Escreva um método chamado mark com um parâmetro: static void mark(int n). Dentro das chavetas imprima esse parâmetro com System.out.println(n);. Em main chame mark(4);. O ecrã deve mostrar uma linha: 4. O nome n existe só dentro de mark. Se tentar imprimir n a partir de main, javac recusa. Essa fronteira — que nomes um método pode ver — é o que esta página ensina.

Nomes que ficam dentro de um método

Na página de sobrecarga, vários métodos paint partilhavam um nome mas mantinham listas de parâmetros separadas. Aqui o foco é mais pequeno: um método, um nome de parâmetro e onde esse nome pode aparecer. Um parâmetro é um nome que pertence ao método que o declara. Fora das chavetas desse método, o nome desaparece.
Crie um ficheiro de programa pequeno chamado Gate.java. O public class da primeira linha deve coincidir com o nome do ficheiro: public class Gate. Não deixe um nome de classe antigo Sign ou Box neste ficheiro; o compilador espera que o nome da classe e o do ficheiro coincidam.
Fora de main, ainda dentro das chavetas da classe, escreva static void mark(int n). O corpo tem uma impressão: System.out.println(n);. Nesta página mantenha void. Está a olhar para a visibilidade, não para valores de retorno. Guarde o ficheiro antes de compilar. O primeiro programa completo está na caixa seguinte.

Gate.java com mark

Esta é a versão que você compila primeiro. main tem a chamada. mark tem a impressão que usa n.

Na pasta que guarda Gate.java, execute javac Gate.java. Quando parênteses, chavetas e ponto e vírgula coincidem, javac não escreve uma linha própria. Depois execute java Gate — não java Gate.java. Tire a terminação .java do segundo comando. Os mesmos dois comandos funcionam no Windows e no macOS. O programa deve imprimir uma linha e parar: 4. Não deve pedir que você digite. Se o terminal esperar entrada do teclado, ainda há uma chamada nextLine de um exercício antigo. Apague-a e mantenha mark(4); mais o método mark acima.
Percorra a execução uma vez por ordem. Java começa em main. A chamada mark(4) envia 4 para o parâmetro n. Dentro de mark, println(n) escreve 4. Quando mark termina, o nome n também termina. main nunca teve um nome n. O número 4 atravessou a chamada como valor. O nome n não se mudou para main.
Se acrescentar System.out.println(n); dentro de main depois da chamada, javac diz que não encontra o símbolo n. Esse erro é a lição: n nunca foi declarado em main. Corrija tirando essa linha de main, ou declare outro nome em main se precisar de um local aí. Não espere que o parâmetro de mark apareça sozinho em main.

Um nome local ao lado do parâmetro

Dentro de mark também pode declarar um nome novo que não é parâmetro. Esse nome local vive só entre as chavetas de mark. Mude o corpo para guardar uma etiqueta e imprimir a etiqueta e n numa linha, ou mantenha um segundo método curto para a demo — nesta página a caixa seguinte mostra em vez disso passar um nome a partir de main, o caminho habitual do principiante.
Uma esperança frequente do principiante é que um nome declarado em main fique automaticamente visível em todos os métodos da classe. Nesta forma, não fica. Se main tem int room = 4; e mark tenta imprimir room sem o receber, javac não encontra room dentro de mark. A correção é passar o valor: mark(room); com mark ainda declarado como mark(int n).

Passar um local de main para mark

Declare int room = 4; dentro de main. Chame mark(room);. Dentro de mark, continue a imprimir n. O ecrã continua a mostrar 4. O nome local em main é room. O nome do parâmetro em mark é n. São nomes diferentes em sítios diferentes. O valor 4 é o que viaja.

Compile e execute de novo: javac Gate.java, depois java Gate. Continua a ver uma linha: 4. Se mudar room para 9 e deixar o corpo do método, o ecrã mostra 9. O método continua a imprimir o valor que chegou em n. main também pode imprimir room se acrescentar System.out.println(room); em main — esse nome pertence ali. main ainda não pode imprimir n.
Se mark declarar o seu próprio local — por exemplo int tag = 1; dentro das chavetas — esse tag é invisível para main. Tentar System.out.println(tag); em main falha pela mesma razão que imprimir n a partir de main. As chavetas de mark são uma parede para nomes declarados lá dentro.

O que a parede protege

Leia a separação com palavras claras. Nomes declarados em main ficam em main salvo se passar os seus valores numa chamada. Nomes declarados em mark — parâmetros e locais — ficam em mark. A chamada transporta valores, não os próprios nomes. A sobrecarga da página anterior é outra habilidade: vários métodos com um mesmo nome de método. Escopo trata de onde um nome de variável ou parâmetro pode aparecer no código-fonte.
Uma demo restante de Sign com vários métodos paint pode ficar no mesmo ficheiro e confundir o ecrã se main ainda chamar paint("ok"). Limpe main até à chamada mark que está a testar. Não aninhe mark dentro das chavetas de main. Os métodos ficam dentro da classe, ao lado de main.
Escrever System.out.println("n"); em main imprime a letra n entre aspas. Não imprime o parâmetro. Mantenha println(n) dentro de mark quando quiser o valor que chegou pela chamada. Escrever mark(); com parênteses vazios falha se o cabeçalho ainda disser mark(int n) — a chamada deve enviar um int, seja um literal como 4 ou um local como room.

Antes de recursion

Você pode escrever mark(int n), imprimir n dentro desse método e manter n fora de main. Pode declarar room em main e passar room para mark. O ecrã mostra o valor que atravessou a chamada. Os nomes não vazam sozinhos pelas chavetas. A página seguinte é recursion, onde um método se chama a si próprio com um argumento mais pequeno até uma condição de paragem terminar a cadeia.