A linha que você digita em Java

Você quer que a tela mostre uma palavra que você digita depois que o programa começou, uma palavra que não está escrita no arquivo. Na página anterior a palavra estava entre aspas na linha de guarda, então outra tela significava editar Mint.java. Nesta página o arquivo não contém leaf de modo nenhum. Ele cria um nome, plant, e depois espera. Você digita leaf e pressiona Enter. A linha de escrita usa o nome só, e o programa escreve leaf. Você não instala o Java outra vez. Você não acrescenta uma nota, e não aprende um segundo modo de terminar uma linha. Você já sabe que um nome pode guardar letras e que println escreve essas letras. O trabalho novo é encher esse nome com a linha que você digita.

O arquivo espera uma linha digitada

Abra Mint.java. O nome do arquivo continua Mint.java, porque public class Mint continua a ser o nome do arquivo. Esta página não muda o nome do arquivo e não muda public class Mint. A primeira linha do arquivo, acima de public class Mint, é import java.util.Scanner;. Essa linha deixa o arquivo usar Scanner. Não é uma linha de escrita. Scanner não é uma letra para a tela. O ponto e vírgula termina a linha de importação. Deixe uma linha em branco embaixo, e depois a mesma public class Mint que você já tem. Este arquivo continua sem uma linha package. A importação é a primeira linha, não uma linha dentro de main.

Dentro de main, a primeira linha nova faz o leitor: Scanner reader = new Scanner(System.in);. Scanner diz que tipo de coisa reader é. reader é o nome, e começa com um r minúsculo. O sinal = guarda esse leitor nesse nome. new Scanner(System.in) faz o leitor e o liga a System.in. System.in é o lugar de onde são lidas as letras que você digita. System.out, que você já usa na linha de escrita, é a tela. Os dois não são a mesma coisa. O ponto e vírgula termina esta linha. Esta linha não escreve a tela, e não espera que você digite. Ela só faz reader.

A linha seguinte enche o nome que você já conhece da página anterior: String plant = reader.nextLine();. String continua a dizer que este nome guarda letras. plant continua a começar com um p minúsculo. O sinal = continua a guardar letras nesse nome. O que é novo é o lado direito. reader.nextLine() não tem aspas. Não há leaf nesta linha. A linha pede a reader uma linha digitada. O programa espera ali até você pressionar Enter. Quando você pressiona Enter, nextLine guarda as letras que você digitou antes desse Enter. Ele não guarda a tecla Enter. Depois a linha termina no ponto e vírgula. Guardar continua a não ser escrever. O programa ainda não escreveu a linha dele.

A linha de escrita continua a ser o nome só, com a mesma forma do arquivo que você guardou na página anterior: System.out.println(plant);. Sem aspas. O Java lê o nome plant, escreve as letras que esse nome guarda e termina a linha. Essas letras são o que nextLine acabou de guardar. Se você digitou leaf, o programa escreve leaf. Se você digitou stem, o programa escreve stem. O arquivo não mudou entre as duas execuções. Guarde o arquivo.

O arquivo que você guarda

Guarde isto como Mint.java. Este é o arquivo que esta página guarda. A palavra que você vai digitar não está no arquivo. Procure no arquivo as letras l, e, a e f. Elas não estão lá. O leitor se chama reader. A linha guardada se chama plant. A linha de escrita usa plant e não contém aspas.

Leia o arquivo de cima e decida o que pode chegar à tela. import java.util.Scanner; só deixa o arquivo usar Scanner. public class Mint dá nome ao arquivo. public static void main(String[] args) é o lugar onde o Java começa. Nenhuma dessas palavras é uma letra para a tela. A palavra String da linha main não é o String que cria plant. Scanner reader = new Scanner(System.in); faz o leitor reader. Ele não escreve nada. String plant = reader.nextLine(); guarda uma linha digitada em plant. Por si só não escreve nada. System.out.println(plant); é a única linha de escrita. Escreve as letras guardadas e termina a linha. O nome plant não é escrito. O nome reader não é escrito. System não é escrito. O ponto e vírgula não é escrito.

O que você digita e o que o programa escreve

Na pasta que contém este Mint.java, digite javac Mint.java. Quando o arquivo está certo, este comando não escreve nenhuma linha. Uma linha de importação e um reader não fazem o javac escrever uma linha, nem o fazem falhar. Depois digite java Mint. Não digite .java depois de java. São esses dois comandos que você digita no Windows e no macOS. Esta página não cita a marca que o shell mostra antes do comando. Essas marcas diferem, e não são a linha do programa.

Depois de java Mint, o programa espera em reader.nextLine(). Ele não terminou, e não escreveu leaf, porque você ainda não lhe deu uma linha. O cursor está numa linha nova. Digite as letras l, e, a e f. O terminal mostra essas letras enquanto você pressiona as teclas. Essa mostra é o terminal repetindo as suas teclas. Não é System.out.println. Depois pressione Enter.

Enter termina a espera. nextLine guarda a palavra leaf em plant e não guarda Enter. println escreve então leaf e termina a linha. Você vê leaf, e embaixo leaf outra vez. O primeiro leaf são as teclas que o terminal mostrou. O segundo leaf é o programa. A linha do programa não tem aspas. Quatro letras, e depois a linha termina. O programa termina depois dessa linha de escrita. Se você quer julgar só a linha do programa, olhe a linha que aparece depois de pressionar Enter.

Se a linha do programa é plant, a linha de escrita tem aspas em volta de plant. O arquivo que você guarda não as tem. Se a linha do programa é mint, a linha de escrita continua System.out.println("mint");, ou o arquivo continua a guardar uma palavra entre aspas de uma página anterior. Se java Mint escreve leaf na hora e nunca espera, o arquivo continua a guardar uma palavra entre aspas, como String plant = "leaf";, e não usa nextLine. Procure aspas em volta de leaf. O arquivo que você guarda não as tem. Você não instala o Java de novo porque a tela mostra a palavra errada.

As maiúsculas são copiadas do jeito que você as digita. Se você digita Leaf com L maiúsculo e pressiona Enter, a linha do programa é Leaf. O arquivo continua sem essas letras. Um Enter vazio também é uma linha de verdade. Pressione Enter sem digitar letras. nextLine não guarda nenhuma letra em plant. println escreve uma linha sem letras. O programa correu. A espera terminou porque você pressionou Enter. O arquivo que você guarda é o que você experimenta com leaf, quatro letras minúsculas.

Um espaço fica na linha

nextLine lê até Enter, não até um espaço. Digite leaf, depois um espaço, depois stem, e depois Enter. As letras guardadas em plant são leaf, um espaço, e stem. System.out.println(plant) escreve leaf stem. O espaço é um carácter guardado, do mesmo modo que na página anterior um espaço dentro das aspas também era guardado. Esta página não corta a linha no espaço. O arquivo que você guarda continua a ler uma só linha. Quando você quer o espaço na tela, muda só o que digita, não o arquivo.

Duas linhas digitadas, dois Enter

Um só reader pode tomar uma segunda linha. Abaixo da primeira linha de escrita, guarde uma linha nova no mesmo nome e depois escreva o nome outra vez. A nova linha de guarda é plant = reader.nextLine();. Ela não começa com String. plant já existe, então esta linha só substitui as letras que o nome guarda. A linha de escrita seguinte é outra vez System.out.println(plant);. O programa agora espera duas vezes. Cada nextLine espera o seu próprio Enter.

Este é o segundo arquivo. Não é o arquivo que você guarda. O arquivo que você guarda espera uma vez e escreve uma vez. Guarde este segundo arquivo como Mint.java quando quiser duas linhas digitadas, e depois volte a pôr o único nextLine e o único println.

Digite javac Mint.java. O arquivo está certo, então o javac não escreve nenhuma linha. A segunda linha de guarda pode omitir String, e essa omissão não faz o javac falhar. Depois digite java Mint. O programa espera. Digite leaf e pressione Enter. O terminal mostra leaf, e o programa escreve leaf embaixo. O programa espera outra vez. Ele não terminou. Digite stem e pressione Enter. O terminal mostra stem, e o programa escreve stem embaixo. As linhas do programa são leaf, e depois stem. As letras que o terminal mostrou a partir das teclas ficam acima de cada uma dessas linhas. Se as duas linhas do programa dizem leaf, o segundo nextLine não correu, ou você digitou leaf as duas vezes. Se o programa escreve stem antes de você ter digitado uma segunda linha, o segundo println não está abaixo de um segundo nextLine. A tela segue a ordem das linhas do arquivo, e cada espera segue o nextLine que ainda não recebeu Enter.

Não escreva String uma segunda vez para o mesmo nome. String plant = reader.nextLine();, abaixo de uma linha que já criou plant, é outro erro. Essa linha tenta criar plant outra vez. O javac escreve um erro e não fica em silêncio. Você não precisa das palavras exatas desse erro. O dado útil é que o javac escreveu uma linha, então você ainda não digita java Mint. Apague o segundo String e deixe plant = reader.nextLine();. O nome é criado uma vez. As linhas seguintes só mudam as letras que ele guarda. No arquivo que você guarda não há um segundo nextLine. Depois de ver leaf e depois stem, volte a pôr o arquivo de uma só linha.

A linha de importação fica acima de public class

O arquivo só conhece Scanner quando a linha de importação está lá. Se você apaga import java.util.Scanner; e deixa o resto do arquivo que você guarda, o javac escreve um erro. Ele não fica em silêncio. Não há tela para ler, porque você não digita java Mint enquanto o javac escreve um erro. Você não precisa das palavras exatas do erro. A correção é voltar a pôr import java.util.Scanner; como primeira linha, acima de public class Mint, com o ponto e vírgula. Guarde, digite javac Mint.java outra vez, e espere até o javac não escrever nenhuma linha.

Este terceiro arquivo não tem a importação. Não é o arquivo que você guarda. Guarde-o só até o javac escrever o erro, e depois volte a pôr a linha de importação.

A linha de importação também falha se você a põe dentro de main, sob a chave de abertura, ou se a põe abaixo de public class. O Java lê uma importação acima de public class, não como um passo dentro de main. Volte a pô-la na primeira linha. Um ponto e vírgula que falta nessa linha é o mesmo tipo de falha: o javac escreve um erro, e você não executa java Mint. O arquivo que você guarda tem o ponto e vírgula.

System.in é o único lugar ao qual esta página liga o leitor. Scanner reader = new Scanner(System.out); pede um leitor na tela. System.out é para onde println escreve. Não é o lugar de onde são lidas as letras digitadas. O javac escreve um erro. Ele não fica em silêncio. Não digite java Mint. Mude System.out para System.in nessa única linha. A linha de escrita fica com System.out, porque a linha de escrita é a tela. A linha de reader fica com System.in, porque a linha de reader é o teclado. Trocar os dois é o erro.

Este quarto arquivo liga o leitor à tela. Não é o arquivo que você guarda. Guarde-o só até o javac escrever o erro, e depois mude out para in.

reader tem de existir primeiro

O Java lê o arquivo de cima. A linha que faz reader tem de estar acima da linha que usa reader. Se String plant = reader.nextLine(); vem primeiro, e só depois Scanner reader = new Scanner(System.in);, a linha de guarda usa o nome reader antes de reader existir. O javac escreve um erro. Ele não fica em silêncio. É a mesma regra de ordem da página anterior, quando plant foi usado antes de String plant. A correção é mover a linha Scanner para cima da linha nextLine. Um nome não é usado numa linha anterior à linha que o cria.

Este quinto arquivo tem a ordem partida. Não é o arquivo que você guarda. Guarde-o só até o javac escrever o erro, e depois volte a pôr a linha Scanner acima de nextLine. A linha de importação continua necessária num arquivo que você de fato executa. Este arquivo partido conserva a importação para que o único erro novo seja a ordem.

Digite javac Mint.java. O javac escreve um erro. Não digite java Mint. Mova Scanner reader = new Scanner(System.in); para cima de String plant = reader.nextLine();. Guarde. Digite javac Mint.java outra vez. Agora o javac não escreve nenhuma linha. Depois java Mint espera. Digite leaf, pressione Enter, e o programa escreve leaf.

Aspas na linha de escrita continuam a significar o mesmo que na página anterior. Depois de um nextLine de verdade, se a linha de escrita é System.out.println("plant");, você pode digitar leaf e pressionar Enter, e a linha do programa continua a ser plant. As aspas marcam as letras p, l, a, n e t. O Java não procura o nome. A linha que você digitou foi guardada em plant e não foi escrita. A correção é o nome só, System.out.println(plant);. O arquivo que você guarda já tem esse nome só. Também não ponha aspas em volta de leaf na linha de guarda. String plant = "leaf"; guardaria leaf a partir do próprio arquivo e nunca esperaria. Esta página deixa nextLine na linha de guarda e deixa a linha de escrita só.

Agora você pode executar Mint.java, esperar, digitar uma linha, pressionar Enter e ver o programa escrever essa linha. import java.util.Scanner; fica acima de public class. Scanner reader = new Scanner(System.in); faz o leitor no teclado. String plant = reader.nextLine(); guarda a linha, sem o Enter. System.out.println(plant); escreve essa linha e termina a linha. Um plant = reader.nextLine(); mais abaixo espera um segundo Enter. A importação, System.in, e o fato de reader existir antes de ser usado, são o que deixa o javac em silêncio. A página seguinte deixa o teclado. Ela olha tipos de valores que um nome pode guardar quando você escreve esses valores no arquivo, e começa pelos números, não por uma linha que você digita.

A tela é a linha que você digitou

O arquivo que você guarda não contém leaf. Você digita leaf depois de java Mint e pressiona Enter. O terminal mostra essa digitação. O programa escreve então leaf na linha seguinte. Um espaço que você digita faz parte dessa linha. Um segundo nextLine é um segundo Enter, e não está no arquivo que você guarda.