Parâmetros em Java

Escreva um método chamado greet que recebe uma palavra. Dentro dos parênteses escreva String name. No corpo imprima hi, um espaço e depois name: System.out.println("hi " + name);. De main chame greet("lena");. A tela deve mostrar uma linha: hi lena. As letras lena não ficam fixas dentro do método. Elas chegam pela chamada e sentam no nome name para aquela passagem. Essa entrega é o que esta página ensina.

Um nome dentro dos parênteses

Na página de métodos, os parênteses depois de ring ficavam vazios. A impressão era sempre ding. Aqui os parênteses guardam um nome tipado para que cada chamada possa enviar um valor diferente. Esse nome tipado é um parâmetro. O valor que você escreve na chamada é o argumento daquela passagem.
Crie um arquivo de programa pequeno chamado Tip.java. O public class da primeira linha deve coincidir com o nome do arquivo: public class Tip. Não deixe um nome de classe antigo Chime ou Pack neste arquivo; o compilador espera que o nome da classe e o do arquivo coincidam.
Fora de main, ainda dentro das chaves da classe, escreva:
static void greet(String name) {
System.out.println("hi " + name);
}
O cabeçalho ainda começa com static void nesta forma iniciante. Entre os parênteses ficam String e depois name — o tipo primeiro, depois o nome do parâmetro. O corpo usa name sem aspas em volta, unido ao texto fixo "hi " com um mais. As aspas em "hi " marcam as letras fixas. O name nu marca o valor que chegou da chamada. Salve o arquivo antes de compilar.

Tip.java com greet

Esta é a versão que você compila primeiro. main guarda a chamada com um valor dentro dos parênteses. greet guarda a impressão que usa esse valor.

Na pasta que guarda Tip.java, execute javac Tip.java. Quando parênteses, chaves e pontos e vírgulas coincidem, o javac não escreve nenhuma linha própria. Depois execute java Tip — não java Tip.java. Tire o final .java do segundo comando. Os mesmos dois comandos funcionam no Windows e no macOS; esta página não precisa de outra ortografia de shell para nenhum dos sistemas. O programa deve imprimir uma linha e parar: hi lena. Não deve pedir que você digite. Se o terminal ficar esperando teclado, ainda há uma chamada nextLine de um exercício antigo no arquivo. Apague essa chamada e conserve greet("lena"); mais o método greet acima. Uma linha errada na tela não significa que você precise reinstalar o JDK.

Percorra uma execução completa na ordem. Java começa em main. A chamada greet("lena"); envia o texto lena para o parâmetro name. Dentro de greet, println monta hi, um espaço e depois aquele valor, então a tela mostra hi lena. Depois greet termina e main termina. Você não escreveu System.out.println("hi lena"); dentro de main. Escreveu a parte fixa uma vez sob greet e passou lena pela chamada.

O mesmo método, palavras diferentes

Mude só main para que chame greet duas vezes com dois argumentos diferentes:
public static void main(String[] args) {
greet("lena");
greet("sam");
}
Deixe o método greet em si sozinho. Compile e execute de novo: javac Tip.java, depois java Tip. A tela deve mostrar duas linhas: hi lena, depois hi sam. A primeira chamada preenche name com lena. A segunda chamada preenche name com sam. Você não copiou o println sob greet. Mudou só os valores dentro das chamadas.
Se você chamar greet() com parênteses vazios enquanto o cabeçalho ainda diz String name, o javac escreve um erro — a chamada deve fornecer um String. Se deixar um ring(); antigo com parênteses vazios da página Chime no mesmo main, essa chamada não combina com greet, e um método ring restante pode ainda imprimir ding ao lado das suas linhas hi. Limpe main até as chamadas greet que esta lição precisa.

Um número inteiro como valor

Parâmetros não servem só para texto. Escreva um segundo método que recebe um int:
static void show(int n) {
System.out.println(n);
}
Chame-o de main com números inteiros:
show(9);
show(4);

Compile e execute: javac Tip.java, depois java Tip. A tela deve mostrar duas linhas: 9, depois 4. Nenhuma aspas envolve 9 ou 4 na chamada — são valores int, não texto. Dentro de show, println(n) escreve o número que chegou. Depois de ver essas duas linhas, você pode colocar de volta a demo greet. As duas versões são Java válido. Elas ensinam a mesma ideia: a chamada envia um valor, o parâmetro o guarda para o corpo.
Leia a execução int mais uma vez. A primeira chamada põe n em 9 e imprime 9. A segunda chamada põe n em 4 e imprime 4. O nome n é declarado uma vez no cabeçalho como int n. Cada chamada dá a ele um valor novo para aquela passagem. Passar uma palavra entre aspas para show, como show("nine");, não combina com int nesta forma — o javac escreve um erro. Passar um número nu para greet, como greet(3);, não combina com String — o javac escreve erro de novo. Faça o tipo do argumento combinar com o tipo do parâmetro.

Uma confusão comum é imprimir o nome do parâmetro como texto: System.out.println("name");. Isso escreve as letras n-a-m-e. Não escreve lena. Conserve println("hi " + name) sem aspas em volta de name quando quiser as letras do argumento na tela. Outra confusão é declarar o parâmetro em main em vez do cabeçalho do método. O nome tipado pertence dentro de greet(...) ou show(...), não dentro dos parênteses de main nesta página. O String[] args de main é outro tema para uma sessão depois; não renomeie args para name esperando que greet o veja.

Onde isto deixa você

Você pode colocar String name ou int n dentro dos parênteses de um método, passar um valor correspondente na chamada e imprimir esse valor a partir do corpo. Duas chamadas com dois argumentos imprimem duas linhas diferentes sem copiar o método. void ainda significa que nada volta pela chamada. A próxima página é return, onde um método devolve um valor a main em vez de só imprimir dentro do corpo.