Letras entre aspas em Java

Você quer que um nome guarde letras que você escreve entre um par de aspas no arquivo, e quer que uma linha de escrita mostre essas letras. Na página anterior o nome guardava um número inteiro, e esse número não tinha aspas em volta. Nesta página o valor são letras, e as aspas são o que as guarda. String plant = "leaf"; guarda as quatro letras leaf. System.out.println(plant) escreve leaf. As aspas ficam no arquivo. Elas não estão na tela. Você não está lendo o teclado. Você não está instalando o Java outra vez, e não está aprendendo um segundo modo de terminar uma linha. Você já sabe que um nome pode guardar a palavra leaf. O trabalho novo é o próprio par: o que fica entre os dois sinais, e o que acontece quando esse par falta.

As aspas guardam as letras

Abra Mint.java. O nome do arquivo continua Mint.java, porque public class Mint continua sendo o nome do arquivo. Esta página não muda o nome do arquivo e não muda public class Mint. A página anterior guardava int count = 4;, sem aspas e sem teclado. Esta página não guarda esse número. Apague a linha int se ela ainda estiver lá. Apague qualquer linha de importação, qualquer linha do reader e qualquer linha do nextLine. O arquivo que você guarda não tem import, não tem Scanner e não tem nextLine. Uma importação sem uso não faz o javac falhar sozinha, e também não escreve as letras. As letras são escritas só pela linha de escrita que usa o nome.

Dentro de main, a linha de guarda é String plant = "leaf";. String é a palavra do tipo. Ela diz que este nome guarda letras. plant é o nome, e começa com um p minúsculo. O sinal = guarda as letras. O par está logo a seguir. A primeira aspa abre as letras. As quatro letras são l, e, a, f, nessa ordem, todas pequenas. A segunda aspa termina as letras. Não há mais nada entre esses dois sinais: nem espaço, nem letra a mais, nem uma segunda palavra. O ponto e vírgula termina a linha. Esta linha não escreve a tela. Guardar não é escrever. A tela fica em branco durante esta linha. As aspas fazem parte da linha de guarda. Depois que a linha guardou as letras, elas não fazem parte do valor que o nome guarda.

A linha de escrita é o nome só: System.out.println(plant);. Sem aspas. O Java lê o nome plant, escreve as letras que esse nome guarda, e termina a linha. Para o arquivo que você guarda, essas letras são l, e, a, f. As aspas não estão na tela. As letras do próprio nome, p, l, a, n, t, não estão na tela. String não está na tela. System não está na tela. O ponto e vírgula não está na tela. Salve o arquivo.

O arquivo que você guarda

Salve isto como Mint.java. É o arquivo que esta página guarda. Uma palavra do tipo, String. Um nome, plant. Um par de aspas. Quatro letras entre elas, leaf. Uma linha de escrita, e essa linha usa o nome só.

Leia de cima. public class Mint nomeia o arquivo. Não escreve a tela. public static void main(String[] args) é onde o Java começa. Nenhuma dessas palavras são as letras na tela. A palavra String na linha de main continua sem ser uma linha de guarda. A linha de guarda é a seguinte, String plant = "leaf";. Essa linha guarda as letras. Não escreve nada. System.out.println(plant); é a única linha de escrita. Escreve leaf e termina a linha. Uma linha. Sem aspas nessa linha da tela.

O que a tela mostra

Na pasta que contém este Mint.java, digite javac Mint.java. Quando o arquivo está certo, esse comando não escreve nenhuma linha. Um par de aspas no arquivo não faz o javac escrever uma linha, e não faz o javac falhar. Depois digite java Mint. Não digite .java depois de java. São os mesmos dois comandos que você digita no Windows e no macOS. Esta página não cita o aviso do shell. O programa escreve leaf. Ele não espera que você digite. As letras já estavam no arquivo. Se java Mint espera, o arquivo ainda tem nextLine. Apague essa linha e guarde String plant = "leaf";. O programa termina depois da linha de escrita.

A tela mostra leaf, uma linha, quatro letras, sem aspas. Se a tela mostra plant, a linha de escrita tem aspas em volta do nome: System.out.println("plant");. Essas aspas marcam as letras p, l, a, n, t. O Java não consulta o nome, então o leaf guardado não é escrito. O arquivo que você guarda tem o nome só na linha de escrita, e as aspas em volta de leaf na linha de guarda. Se a tela mostra mint, você ainda está num arquivo anterior. Se a tela mostra 4, o arquivo ainda tem o número inteiro da página anterior, ou as letras entre as aspas são o dígito 4. O arquivo que você guarda tem leaf, não 4. Você não reinstala o Java por uma tela que mostra a linha errada.

Uma letra maiúscula entre as aspas é guardada como essa maiúscula. String plant = "Leaf"; faria a linha de escrita escrever Leaf, com um L grande. O arquivo que você guarda não usa isso. Ele usa quatro letras pequenas. Julgue a tela pelas letras que de fato estão entre as aspas, não por uma palavra que você só pretendia escrever.

Um espaço é uma das letras

A linha de escrita pode ficar no lugar enquanto as letras entre as aspas mudam. Abaixo da primeira linha de escrita, guarde um novo conjunto de letras no mesmo nome, e depois escreva o nome de novo. A nova linha de guarda é plant = "leaf stem";. Ela não começa com String. plant já existe, então esta linha só troca as letras que o nome guarda. Entre os sinais, desta vez, há nove lugares: l, e, a, f, um espaço, s, t, e, m. O espaço é um deles. Não é uma divisão em duas linhas de guarda, e não é apagado quando a tela é escrita. A linha de escrita seguinte é de novo System.out.println(plant);. A tela agora tem duas linhas. A primeira é leaf, das letras que o nome guardava naquele momento. A segunda é leaf stem, das letras que o nome guarda depois de plant = "leaf stem";. Um espaço fica entre leaf e stem nessa segunda linha. As duas palavras não estão em duas linhas separadas.

Este é o segundo arquivo. Não é o arquivo que você guarda. O arquivo que você guarda tem uma linha de guarda, as letras leaf, e nenhum espaço. Salve este segundo arquivo como Mint.java quando quiser ver o espaço, e depois volte a deixar a linha de guarda única e a linha de escrita única.

Digite javac Mint.java. O arquivo está certo, então o javac não escreve nenhuma linha. A segunda linha de guarda pode deixar de escrever String, e essa ausência não faz o javac falhar. Depois digite java Mint. A tela mostra leaf, e a linha seguinte é leaf stem. Duas linhas. Sem aspas. O nome plant não está em nenhuma das duas linhas. Se a segunda linha for leafstem, sem vão, o espaço falta entre as aspas. Se as duas linhas dizem leaf, a segunda linha de guarda falta ou ainda diz "leaf". Se as duas dizem leaf stem, a primeira linha de guarda já diz "leaf stem", ou a primeira linha de escrita está abaixo da mudança. A tela segue a ordem das linhas no arquivo, e segue as letras entre as aspas, espaço incluído.

Não escreva String uma segunda vez para o mesmo nome. String plant = "leaf stem";, colocado sob uma linha que já criou plant, é um erro diferente. Essa linha tenta criar plant de novo. O javac escreve um erro e não fica em silêncio. Você não precisa das palavras exatas desse erro. Ainda não digite java Mint. Apague o segundo String e deixe plant = "leaf stem";. O nome é criado uma vez. As linhas seguintes só mudam as letras que ele guarda. No arquivo que você guarda não há uma segunda linha de guarda. Depois de ver leaf e depois leaf stem, volte a deixar esse arquivo: um String plant = "leaf"; e um System.out.println(plant);.

Nada entre as aspas

Um par pode estar vazio. String plant = ""; tem a aspa que abre e a aspa que termina, e nenhuma letra entre elas. A palavra do tipo continua String. O nome continua plant. O sinal = continua guardando. O que ele guarda é nenhuma letra. Isso é permitido. O javac não escreve um erro para um par vazio. System.out.println(plant); ainda executa. Escreve as letras que o nome guarda, e não há nenhuma, então a linha da tela não tem letras. A linha ainda termina. O programa ainda termina. Você vê uma linha em branco onde leaf teria estado. Essa linha em branco é a escrita. Não é uma espera, e não é uma falha do javac.

Este é o terceiro arquivo. Não é o arquivo que você guarda. O arquivo que você guarda tem leaf entre as aspas. Salve este terceiro arquivo só até ver a linha em branco, e depois volte a deixar "leaf" entre as aspas.

Digite javac Mint.java. O par vazio é permitido, então o javac não escreve nenhuma linha. Depois digite java Mint. O programa escreve uma linha sem letras e termina. Ele não espera. Se você ainda vê leaf, as aspas ainda têm leaf entre elas. Se java Mint espera, nextLine ainda está no arquivo. Depois de ver a linha em branco, faça a linha de guarda ser de novo String plant = "leaf";.

Sem aspas, leaf é um nome

O par é que faz o trabalho. Tire as duas aspas e a linha fica String plant = leaf;. Não há par, então leaf não são letras. O Java lê leaf como um nome, e este arquivo não tem um nome leaf. 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. O fato útil é que o javac escreveu uma linha. O conserto é pôr o par de volta, para a linha ser de novo String plant = "leaf";.

Uma aspa só também não é um par. String plant = "leaf; abre as letras e não as termina antes do ponto e vírgula. O javac escreve um erro para essa linha também. Ele não guarda metade de uma palavra, e não adivinha onde as letras deviam terminar. Ponha a segunda aspa antes do ponto e vírgula. O arquivo que você guarda tem as duas aspas, com leaf entre elas.

Este quarto arquivo é o par que falta. Não é o arquivo que você guarda. Salve-o só até o javac escrever o erro, e depois volte a pôr as aspas em volta de leaf.

Digite javac Mint.java. O javac escreve um erro. Não digite java Mint. Ponha uma aspa antes de l e uma aspa depois de f, para a linha ficar String plant = "leaf";. Salve. Digite javac Mint.java outra vez. Agora o javac não escreve nenhuma linha. Depois java Mint escreve leaf.

O nome ainda tem de existir antes de uma linha usá-lo. Se System.out.println(plant); estiver escrito acima de String plant = "leaf";, o javac escreve um erro. A linha de escrita nomeia plant antes de plant existir. Mova a linha String para cima da linha de escrita. É a mesma ordem que você já usou para count e para reader. O arquivo que você guarda já tem essa ordem.

Letras ainda não cabem num inteiro. int plant = "leaf"; pede a um nome int que guarde letras. O javac escreve um erro. O conserto nesta página não é apagar as aspas. O conserto é manter a palavra do tipo String, porque as aspas estão guardando letras. A página anterior guardava int e guardava 4. Esta página guarda String e guarda "leaf".

Agora você pode guardar letras entre um par de aspas e escrever essas letras sem escrever as aspas. String plant = "leaf"; guarda leaf. System.out.println(plant); escreve leaf e termina a linha. Um plant = "leaf stem"; depois muda as letras guardadas sem um segundo String, e o espaço entre as aspas é uma dessas letras. Um par vazio não guarda letras, e a linha de escrita escreve uma linha em branco. Sem aspas, leaf é um nome que este arquivo não tem, e o javac escreve um erro. A página seguinte fica com estas letras. Ela olha perguntas que você pode fazer sobre as letras que um nome já guarda.

A tela é as letras entre as aspas

O arquivo que você guarda escreve leaf. O nome na linha de escrita é plant, e plant não está na tela. As aspas estão no arquivo, em volta de leaf, e não estão na tela. Um println é uma linha. Um espaço entre as aspas fica nessa linha. Um par vazio escreve uma linha sem letras.