Duas palavras sob um nome em Java

String[] plants = { "leaf", "mint" }; guarda duas palavras sob um nome, e System.out.println(plants[0]) escreve leaf. A tela é uma linha. mint não está nessa linha, e não há uma segunda linha.

Um nome guarda duas palavras

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. Apague String plant = null se essa linha ainda estiver lá. Apague plant.length e apague charAt. Apague int count se essa linha ainda estiver lá, inclusive (int), 40.0, 40.9 e 40. Apague double weight se ainda estiver lá. Apague boolean ripe se ainda estiver lá, inclusive true e false. Apague qualquer linha de import, qualquer linha do reader e qualquer linha do nextLine. O arquivo que você guarda não tem import, não tem Scanner, não tem nextLine, não tem count, não tem weight, não tem ripe e não tem um plant sozinho que guarde null. Uma importação sem uso não faz o javac falhar sozinha, e também não escreve leaf. A palavra é escrita só pela linha de escrita que escolhe um lugar.

Dentro de main, a linha de guarda é String[] plants = { "leaf", "mint" };. String[] é a palavra do tipo. Os colchetes fazem parte desse tipo. Eles dizem que este nome pode guardar mais de uma palavra. plants é o nome, e começa com um p minúsculo. O sinal = guarda. As chaves guardam as palavras. Cada palavra fica nas próprias aspas. Uma vírgula fica entre as palavras. leaf é a primeira palavra. mint é a segunda palavra. O ponto e vírgula termina a linha. Esta linha guarda duas palavras. Não escreve a tela. Guardar não é escrever. A tela fica em branco durante esta linha. As duas palavras não são o número 0, e não são a palavra null. Nada espera fora da tela sob um segundo nome. As duas palavras estão sob plants.

As palavras que você escreve dentro das chaves são os lugares. Duas palavras entre aspas fazem dois lugares. Você não inventa uma terceira palavra no arquivo que você guarda. String[] plants = { "leaf", "mint", "stem" }; guarda três palavras. Esse arquivo é permitido, e não é o arquivo que você guarda. String[] plants = { leaf, mint }; trata leaf e mint como nomes. Este arquivo não tem esses nomes. O javac escreve um erro. String[] plants = { "leaf" "mint" }; não tem vírgula. O javac escreve um erro. A vírgula é o que separa as duas palavras. String[] plants = { 40, 9 }; pede a este tipo que guarde números inteiros. As palavras do arquivo que você guarda são leaf e mint, não dígitos. O javac escreve um erro. A palavra do tipo com os colchetes, nesta página, guarda palavras entre aspas.

A linha de escrita escolhe um lugar: System.out.println(plants[0]);. Os colchetes depois do nome guardam um número. Esse número é 0. O lugar 0 é a primeira palavra, porque a contagem dos lugares começa em 0, não em 1. Não há aspas em volta de 0. Não há ponto, e não há length. O Java lê plants, lê o número 0, escreve a palavra desse lugar e termina a linha. Para o arquivo que você guarda, essa palavra é leaf. As letras do próprio nome, p, l, a, n, t, s, não estão na tela. String não está na tela. As chaves não estão na tela. A vírgula não está na tela. mint não está na tela. A palavra leaf está na tela, numa linha. 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, plants. Duas palavras em chaves, leaf e depois mint, cada uma entre aspas, com uma vírgula entre elas. Uma linha de escrita, e essa linha escolhe o lugar 0. Não há length, não há charAt e não há uma segunda linha de escrita.

Leia de cima. public class Mint dá nome ao arquivo. Não escreve a tela. public static void main(String[] args) é onde o Java começa. A palavra String nessa linha main ainda não é uma linha de guarda. Os colchetes dessa linha main pertencem a args, e esta página não lê args. A linha de guarda é a seguinte, String[] plants = { "leaf", "mint" };. Não escreve nada. System.out.println(plants[0]); escreve leaf e termina a linha. Uma linha na tela. Sem segunda linha. Não há uma linha int no arquivo que você guarda, e não há uma linha que guarde null.

O que a tela mostra

Na pasta que contém este Mint.java, escreva javac Mint.java. Quando o arquivo está certo, esse comando não escreve nenhuma linha. Os colchetes e as chaves não fazem o javac escrever uma linha, e não fazem o javac falhar. Depois escreva java Mint. Não escreva .java depois de java. São os mesmos dois comandos que você escreve no Windows e no macOS. Esta página não cita a marca que o shell mostra antes do comando. O programa escreve leaf. Não espera que você escreva algo. As palavras estavam no arquivo antes da execução. Se java Mint espera, nextLine ainda está no arquivo. Apague essa linha e deixe String[] plants = { "leaf", "mint" }; e a única linha de escrita. O programa termina depois da linha de escrita.

A tela mostra leaf. Uma linha. Se a tela mostra mint, a linha de escrita escolheu o lugar 1, ou a primeira palavra dentro das chaves é mint. Olhe o arquivo. O arquivo que você guarda tem leaf primeiro e plants[0] na linha de escrita. Se a tela mostra plant, a linha de escrita tem aspas em volta de outro nome. Se a tela mostra as letras plants[0], a linha de escrita tem aspas em volta dessas letras: System.out.println("plants[0]");. Essas aspas marcam letras, então a palavra guardada não é escrita. Se a tela mostra null, o arquivo de null ainda está no lugar, ou os lugares foram criados sem palavras dentro das chaves. O arquivo que você guarda tem leaf e mint dentro das chaves. Se a tela mostra 40, ou 40.0, ou 4, o arquivo dos parênteses, o arquivo dos números ou uma pergunta length ainda está no lugar. Apague essa linha. Se a tela mostra true ou false, ripe ainda está no arquivo. Se a tela mostra uma linha em branco e não a palavra leaf, uma linha de guarda ainda tem aspas e nada entre elas. Esse não é o arquivo que você guarda. Você não instala o Java de novo porque a tela mostra a linha errada.

Uma tela que mostra leaf não prova os colchetes sozinha. String plant = "leaf"; também escreve leaf. A tela pode parecer igual. O arquivo não. O arquivo que você guarda tem String[], tem chaves, tem uma vírgula, e a linha de escrita tem plants[0]. Quando você julga esta página, procure os colchetes na palavra do tipo e procure o número 0. Não julgue o arquivo só pela tela.

A outra palavra fica no lugar 1

A segunda palavra está no arquivo, e a linha de escrita que você guarda não a escreve. Para ver mint, o número dentro dos colchetes é 1. O lugar 1 é a segunda palavra, porque o lugar 0 foi a primeira. Essa execução é permitida, e não é o arquivo que você guarda.

Escreva javac Mint.java. O javac não escreve nenhuma linha. Depois escreva java Mint. A tela mostra mint. Uma linha. leaf não está nessa linha. A linha de guarda não mudou. Só o número dentro dos colchetes mudou. 1 não quer dizer «a primeira palavra». A primeira palavra continua sendo leaf, no lugar 0. Depois de ver mint, volte a pôr plants[0]. O arquivo que você guarda escreve leaf.

Leia a tabela ao lado de uma execução, não no lugar de uma. Para 0, o javac não escreve nenhuma linha e java Mint escreve leaf. Para 1, o javac não escreve nenhuma linha e java Mint escreve mint. Para 2, o javac não escreve nenhuma linha e java Mint escreve um erro, porque esse lugar não estava dentro das chaves. Para String plants = { "leaf", "mint" }; sem colchetes na palavra do tipo, o javac escreve um erro, então você não escreve java Mint. Depois de cada verificação, volte a pôr o arquivo que você guarda: String[], chaves, leaf e depois mint, e plants[0]. A tela guardada é leaf, uma linha.

O nome tem de existir antes de uma linha usá-lo. Se System.out.println(plants[0]); está escrito acima da linha de guarda, o javac escreve um erro. A linha de escrita nomeia plants antes de plants existir. Coloque a linha de guarda acima da linha de escrita. Não escreva String[] uma segunda vez para o mesmo nome. Uma linha posterior pode trocar uma palavra sem escrever String[] de novo, uma vez que plants já existe: plants[0] = "stem";. Essa linha só troca a palavra do lugar 0. O lugar 1 ainda guarda mint. É permitida. Não é o arquivo que você guarda. O arquivo que você guarda tem uma linha de guarda, e essa linha diz leaf e depois mint.

String[] plants; sem chaves e sem palavras, seguido da linha de escrita, faz o javac escrever um erro. O nome existiria como um tipo, e ainda não guardaria nenhuma palavra. Ponha as chaves na linha que cria o nome, como o arquivo que você guarda. String[] plants = { "leaf" }; guarda uma palavra. plants[0] escreve leaf. plants[1] é um lugar que você não escreveu, então java Mint escreve um erro depois de o javac ficar quieto. Esse arquivo de uma palavra não é o arquivo que você guarda. A falta de um espaço não cola a palavra do tipo num tipo novo que funcione: String[]plants ainda guarda as duas palavras, e o javac não escreve nenhuma linha. O arquivo que você guarda tem um espaço depois de String[]. String [] plants com um espaço antes de plants ainda guarda as duas palavras. plants[ 0 ] com espaços dentro dos colchetes ainda escreve leaf. O arquivo que você guarda não tem esse espaço a mais, mas esse espaço não é um segundo valor.

As chaves não são parênteses. String[] plants = ( "leaf", "mint" ); faz o javac escrever um erro. As palavras ficam dentro de chaves, { e }, não dentro de ( e ). A linha de escrita não põe o número dentro de parênteses. System.out.println(plants(0)); faz o javac escrever um erro. O número fica dentro de colchetes, [ e ]. Um s minúsculo na palavra do tipo não é o tipo. string[] plants = { "leaf", "mint" }; trata string como um nome. Este arquivo não tem esse nome. O javac escreve um erro. A palavra do tipo é String, com S maiúsculo, e depois os colchetes. O nome continua plants, com p minúsculo. String[] Plants com P maiúsculo é outro nome. Ele pode guardar as palavras, e não é o nome do arquivo que você guarda. Volte a pôr o p minúsculo.

Uma vírgula depois da última palavra não acrescenta um lugar. String[] plants = { "leaf", "mint", }; ainda guarda duas palavras. O javac não escreve nenhuma linha. plants[0] ainda escreve leaf, e plants[1] ainda escreve mint. Não há uma terceira palavra. O arquivo que você guarda não tem vírgula depois de mint, mas essa vírgula a mais não é um terceiro valor. new não é preciso. String[] plants = new String[] { "leaf", "mint" }; também guarda as duas palavras, e plants[0] ainda escreve leaf. O arquivo que você guarda não escreve new. String[] plants = new String[2]; cria dois lugares e não põe palavras neles. plants[0] escreve então null. Esses lugares não guardam nenhuma letra. Esse não é o arquivo que você guarda. As palavras leaf e mint têm de ficar dentro das chaves.

Um lugar que você não escreveu

Duas palavras fazem dois lugares, numerados 0 e 1. O número 2 é um terceiro lugar. Você não escreveu uma terceira palavra. O terceiro arquivo pede esse lugar.

Este é o terceiro arquivo. Não é o arquivo que você guarda. Escreva javac Mint.java. O arquivo está certo no que o javac pode ver, então o javac não escreve nenhuma linha. O número 2 não faz o javac falhar. Depois escreva java Mint. O programa não escreve leaf, não escreve mint, não escreve 2 e não escreve null. java Mint escreve um erro. Você não precisa do texto exato desse erro. As chaves guardavam duas palavras, então não há uma terceira palavra para escrever. plants[-1] não é um jeito de escolher a última palavra. O javac não escreve nenhuma linha, e java Mint escreve um erro. Os números que combinam com o arquivo que você guarda são só 0 e 1. Se a tela mostra mint, o número dentro dos colchetes é 1, e a segunda palavra ainda está lá. Depois de ver o erro, volte a pôr o arquivo guardado.

Um nome que não guarda nenhum lugar é outra falha, e a tela não é a palavra null. String[] plants = null; não guarda nenhum lugar. O javac não escreve nenhuma linha. System.out.println(plants[0]); faz então java Mint escrever um erro. Não escreve null, e não escreve leaf. Os colchetes da linha de escrita pedem um lugar, e este nome não tem lugares. Esse arquivo não é o arquivo que você guarda. O arquivo que você guarda tem chaves, e as chaves guardam leaf e mint.

Agora você pode guardar duas palavras sob um nome e escrever a primeira palavra. String[] plants = { "leaf", "mint" }; guarda leaf e mint. System.out.println(plants[0]); escreve leaf e termina a linha. plants[1] escreve mint, e esse não é o arquivo que você guarda. plants[2] deixa o javac quieto e faz java Mint escrever um erro. Um nome String sem colchetes não pode guardar as chaves. A página seguinte deixa estes colchetes. Ela olha uma marca escrita entre dois números inteiros.

A tela é a primeira palavra

O arquivo que você guarda escreve leaf. O nome na linha de escrita é plants, e plants não está na tela. O número dentro dos colchetes é 0. mint é a segunda palavra, e fica no arquivo enquanto a tela mostra leaf. Um número de lugar que você não escreveu não é o arquivo que você guarda. Aspas em volta de plants[0] escrevem letras, não a palavra do lugar.