Dos palabras bajo un nombre en Java

String[] plants = { "leaf", "mint" }; guarda dos palabras bajo un nombre, y System.out.println(plants[0]) escribe leaf. La pantalla es una línea. mint no está en esa línea, y no hay una segunda línea.

Un nombre guarda dos palabras

Abre Mint.java. El nombre del archivo sigue siendo Mint.java, porque public class Mint sigue siendo el nombre del archivo. Esta página no cambia el nombre del archivo y no cambia public class Mint. Borra String plant = null si esa línea todavía está. Borra plant.length y borra charAt. Borra int count si esa línea todavía está, incluido (int), 40.0, 40.9 y 40. Borra double weight si todavía está. Borra boolean ripe si todavía está, incluido true y false. Borra cualquier línea import, cualquier línea reader y cualquier línea nextLine. El archivo que guardas no tiene import, no tiene Scanner, no tiene nextLine, no tiene count, no tiene weight, no tiene ripe y no tiene un plant solo que guarde null. Un import sin uso no hace fallar a javac por sí solo, y tampoco escribe leaf. La palabra la escribe solo la línea de escritura que elige un lugar.

Dentro de main, la línea de guardado es String[] plants = { "leaf", "mint" };. String[] es la palabra del tipo. Los corchetes son parte de ese tipo. Dicen que este nombre puede guardar más de una palabra. plants es el nombre, y empieza con una p minúscula. El signo = guarda. Las llaves guardan las palabras. Cada palabra está en sus propias comillas. Una coma está entre las palabras. leaf es la primera palabra. mint es la segunda palabra. El punto y coma termina la línea. Esta línea guarda dos palabras. No escribe la pantalla. Guardar no es escribir. La pantalla se queda en blanco durante esta línea. Las dos palabras no son el número 0, y no son la palabra null. Nada espera fuera de la pantalla bajo un segundo nombre. Las dos palabras están bajo plants.

Las palabras que escribes dentro de las llaves son los lugares. Dos palabras entre comillas hacen dos lugares. No inventas una tercera palabra en el archivo que guardas. String[] plants = { "leaf", "mint", "stem" }; guarda tres palabras. Ese archivo está permitido, y no es el archivo que guardas. String[] plants = { leaf, mint }; trata leaf y mint como nombres. Este archivo no tiene esos nombres. javac escribe un error. String[] plants = { "leaf" "mint" }; no tiene coma. javac escribe un error. La coma es lo que separa las dos palabras. String[] plants = { 40, 9 }; pide a este tipo que guarde números enteros. Las palabras del archivo que guardas son leaf y mint, no dígitos. javac escribe un error. La palabra del tipo con los corchetes, en esta página, guarda palabras entre comillas.

La línea de escritura elige un lugar: System.out.println(plants[0]);. Los corchetes después del nombre guardan un número. Ese número es 0. El lugar 0 es la primera palabra, porque la cuenta de lugares empieza en 0, no en 1. No hay comillas alrededor de 0. No hay punto, y no hay length. Java lee plants, lee el número 0, escribe la palabra de ese lugar y termina la línea. Para el archivo que guardas, esa palabra es leaf. Las letras del propio nombre, p, l, a, n, t, s, no están en la pantalla. String no está en la pantalla. Las llaves no están en la pantalla. La coma no está en la pantalla. mint no está en la pantalla. La palabra leaf está en la pantalla, en una línea. Guarda el archivo.

El archivo que guardas

Guarda esto como Mint.java. Es el archivo que esta página guarda. Una palabra del tipo, String[]. Un nombre, plants. Dos palabras en llaves, leaf y luego mint, cada una entre comillas, con una coma entre ellas. Una línea de escritura, y esa línea elige el lugar 0. No hay length, no hay charAt y no hay una segunda línea de escritura.

Léelo desde arriba. public class Mint nombra el archivo. No escribe la pantalla. public static void main(String[] args) es donde Java empieza. La palabra String en esa línea main todavía no es una línea de guardado. Los corchetes de esa línea main pertenecen a args, y esta página no lee args. La línea de guardado es la posterior, String[] plants = { "leaf", "mint" };. No escribe nada. System.out.println(plants[0]); escribe leaf y termina la línea. Una línea en la pantalla. Sin segunda línea. No hay una línea int en el archivo que guardas, y no hay una línea que guarde null.

Lo que muestra la pantalla

En la carpeta que contiene este Mint.java, escribe javac Mint.java. Cuando el archivo está bien, ese comando no escribe ninguna línea. Los corchetes y las llaves no hacen que javac escriba una línea, y no hacen que javac falle. Luego escribe java Mint. No escribas .java después de java. Los mismos dos comandos son los que escribes en Windows y en macOS. Esta página no cita la marca que el shell muestra antes del comando. El programa escribe leaf. No espera a que escribas algo. Las palabras estaban en el archivo antes de la ejecución. Si java Mint espera, nextLine sigue en el archivo. Borra esa línea y deja String[] plants = { "leaf", "mint" }; y la única línea de escritura. El programa termina después de la línea de escritura.

La pantalla muestra leaf. Una línea. Si la pantalla muestra mint, la línea de escritura eligió el lugar 1, o la primera palabra dentro de las llaves es mint. Mira el archivo. El archivo que guardas tiene leaf primero y plants[0] en la línea de escritura. Si la pantalla muestra plant, la línea de escritura tiene comillas alrededor de otro nombre. Si la pantalla muestra las letras plants[0], la línea de escritura tiene comillas alrededor de esas letras: System.out.println("plants[0]");. Esas comillas marcan letras, así que la palabra guardada no se escribe. Si la pantalla muestra null, el archivo de null sigue en su sitio, o los lugares se crearon sin palabras dentro de las llaves. El archivo que guardas tiene leaf y mint dentro de las llaves. Si la pantalla muestra 40, o 40.0, o 4, el archivo de los paréntesis, el archivo de los números o una pregunta length sigue en su sitio. Borra esa línea. Si la pantalla muestra true o false, ripe sigue en el archivo. Si la pantalla muestra una línea en blanco y no la palabra leaf, una línea de guardado todavía tiene comillas y nada entre ellas. Ese no es el archivo que guardas. No vuelves a instalar Java porque la pantalla muestre la línea equivocada.

Una pantalla que muestra leaf no prueba los corchetes por sí sola. String plant = "leaf"; también escribe leaf. La pantalla puede verse igual. El archivo no. El archivo que guardas tiene String[], tiene llaves, tiene una coma, y la línea de escritura tiene plants[0]. Cuando juzgas esta página, busca los corchetes en la palabra del tipo y busca el número 0. No juzgues el archivo solo por la pantalla.

La otra palabra está en 1

La segunda palabra está en el archivo, y la línea de escritura que guardas no la escribe. Para ver mint, el número dentro de los corchetes es 1. El lugar 1 es la segunda palabra, porque el lugar 0 fue la primera. Esta ejecución está permitida, y no es el archivo que guardas.

Escribe javac Mint.java. javac no escribe ninguna línea. Luego escribe java Mint. La pantalla muestra mint. Una línea. leaf no está en esa línea. La línea de guardado no cambió. Solo cambió el número dentro de los corchetes. 1 no significa «la primera palabra». La primera palabra sigue siendo leaf, en el lugar 0. Después de ver mint, vuelve a poner plants[0]. El archivo que guardas escribe leaf.

Lee la tabla junto a una ejecución, no en lugar de una. Para 0, javac no escribe ninguna línea y java Mint escribe leaf. Para 1, javac no escribe ninguna línea y java Mint escribe mint. Para 2, javac no escribe ninguna línea y java Mint escribe un error, porque ese lugar no estaba dentro de las llaves. Para String plants = { "leaf", "mint" }; sin corchetes en la palabra del tipo, javac escribe un error, así que no escribes java Mint. Después de cada comprobación, vuelve a poner el archivo que guardas: String[], llaves, leaf y luego mint, y plants[0]. La pantalla que guardas es leaf, una línea.

El nombre tiene que existir antes de que una línea lo use. Si System.out.println(plants[0]); está escrito encima de la línea de guardado, javac escribe un error. La línea de escritura nombra plants antes de que plants exista. Mueve la línea de guardado por encima de la línea de escritura. No escribas String[] una segunda vez para el mismo nombre. Una línea posterior puede sustituir una palabra sin escribir String[] otra vez, una vez que plants ya existe: plants[0] = "stem";. Esa línea solo sustituye la palabra del lugar 0. El lugar 1 sigue guardando mint. Está permitida. No es el archivo que guardas. El archivo que guardas tiene una línea de guardado, y esa línea dice leaf y luego mint.

String[] plants; sin llaves y sin palabras, seguido de la línea de escritura, hace que javac escriba un error. El nombre existiría como un tipo, y todavía no guardaría ninguna palabra. Pon las llaves en la línea que crea el nombre, como lo tiene el archivo que guardas. String[] plants = { "leaf" }; guarda una palabra. plants[0] escribe leaf. plants[1] es un lugar que no escribiste, así que java Mint escribe un error después de que javac se queda callado. Ese archivo de una palabra no es el archivo que guardas. La falta de un espacio no pega la palabra del tipo en un tipo nuevo que funcione: String[]plants sigue guardando las dos palabras, y javac no escribe ninguna línea. El archivo que guardas tiene un espacio después de String[]. String [] plants con un espacio antes de plants sigue guardando las dos palabras. plants[ 0 ] con espacios dentro de los corchetes sigue escribiendo leaf. El archivo que guardas no tiene ese espacio de más, pero ese espacio no es un segundo valor.

Las llaves no son paréntesis. String[] plants = ( "leaf", "mint" ); hace que javac escriba un error. Las palabras se sientan dentro de llaves, { y }, no dentro de ( y ). La línea de escritura no pone el número dentro de paréntesis. System.out.println(plants(0)); hace que javac escriba un error. El número se sienta dentro de corchetes, [ y ]. Una s minúscula en la palabra del tipo no es el tipo. string[] plants = { "leaf", "mint" }; trata string como un nombre. Este archivo no tiene ese nombre. javac escribe un error. La palabra del tipo es String, con una S mayúscula, y luego los corchetes. El nombre sigue siendo plants, con una p minúscula. String[] Plants con una P mayúscula es otro nombre. Puede guardar las palabras, y no es el nombre del archivo que guardas. Vuelve a poner la p minúscula.

Una coma después de la última palabra no añade un lugar. String[] plants = { "leaf", "mint", }; sigue guardando dos palabras. javac no escribe ninguna línea. plants[0] sigue escribiendo leaf, y plants[1] sigue escribiendo mint. No hay una tercera palabra. El archivo que guardas no tiene coma después de mint, pero esa coma de más no es un tercer valor. new no hace falta. String[] plants = new String[] { "leaf", "mint" }; también guarda las dos palabras, y plants[0] sigue escribiendo leaf. El archivo que guardas no escribe new. String[] plants = new String[2]; crea dos lugares y no pone palabras en ellos. plants[0] escribe entonces null. Esos lugares no guardan ninguna letra. Ese no es el archivo que guardas. Las palabras leaf y mint tienen que sentarse dentro de las llaves.

Un lugar que no escribiste

Dos palabras hacen dos lugares, numerados 0 y 1. El número 2 es un tercer lugar. No escribiste una tercera palabra. El tercer archivo pide ese lugar.

Este es el tercer archivo. No es el archivo que guardas. Escribe javac Mint.java. El archivo está bien en lo que javac puede ver, así que javac no escribe ninguna línea. El número 2 no hace fallar a javac. Luego escribe java Mint. El programa no escribe leaf, no escribe mint, no escribe 2 y no escribe null. java Mint escribe un error. No necesitas el texto exacto de ese error. Las llaves guardaban dos palabras, así que no hay una tercera palabra que escribir. plants[-1] no es una forma de elegir la última palabra. javac no escribe ninguna línea, y java Mint escribe un error. Los números que coinciden con el archivo que guardas son solo 0 y 1. Si la pantalla muestra mint, el número dentro de los corchetes es 1, y la segunda palabra sigue ahí. Después de ver el error, vuelve a poner el archivo que guardas.

Un nombre que no guarda ningún lugar es otro fallo, y la pantalla no es la palabra null. String[] plants = null; no guarda ningún lugar. javac no escribe ninguna línea. System.out.println(plants[0]); hace entonces que java Mint escriba un error. No escribe null, y no escribe leaf. Los corchetes de la línea de escritura piden un lugar, y este nombre no tiene lugares. Ese archivo no es el archivo que guardas. El archivo que guardas tiene llaves, y las llaves guardan leaf y mint.

Ahora puedes guardar dos palabras bajo un nombre y escribir la primera palabra. String[] plants = { "leaf", "mint" }; guarda leaf y mint. System.out.println(plants[0]); escribe leaf y termina la línea. plants[1] escribe mint, y ese no es el archivo que guardas. plants[2] deja a javac callado y hace que java Mint escriba un error. Un nombre String sin corchetes no puede guardar las llaves. La página siguiente deja estos corchetes. Mira una marca escrita entre dos números enteros.

La pantalla es la primera palabra

El archivo que guardas escribe leaf. El nombre en la línea de escritura es plants, y plants no está en la pantalla. El número dentro de los corchetes es 0. mint es la segunda palabra, y se queda en el archivo mientras la pantalla muestra leaf. Un número de lugar que no escribiste no es el archivo que guardas. Las comillas alrededor de plants[0] escriben letras, no la palabra del lugar.