Letras entre comillas en Java

Quieres que un nombre guarde letras que escribes entre un par de comillas en el archivo, y quieres que una línea de escritura muestre esas letras. En la página anterior el nombre guardaba un número entero, y ese número no tenía comillas alrededor. En esta página el valor son letras, y las comillas son lo que las guarda. String plant = "leaf"; guarda las cuatro letras leaf. System.out.println(plant) escribe leaf. Las comillas se quedan en el archivo. No están en la pantalla. No estás leyendo el teclado. No estás instalando Java otra vez, y no estás aprendiendo una segunda forma de terminar una línea. Ya sabes que un nombre puede guardar la palabra leaf. El trabajo nuevo es el par de comillas: qué hay entre las dos, y qué pasa cuando ese par falta.

Las comillas guardan las letras

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 ni cambia public class Mint. La página anterior conservaba int count = 4;, sin comillas y sin teclado. Esta página no conserva ese número. Borra la línea int si todavía está. Borra cualquier línea de importación, cualquier línea de reader y cualquier línea de nextLine. El archivo que conservas no tiene import, ni Scanner, ni nextLine. Una importación sin uso no hace fallar a javac por sí sola, y tampoco escribe las letras. Las letras las escribe solo la línea de escritura que usa el nombre.

Dentro de main, la línea de guardado es String plant = "leaf";. String es la palabra del tipo. Dice que este nombre guarda letras. plant es el nombre, y empieza con una p minúscula. El signo = guarda las letras. Después está el par. La primera comilla abre las letras. Las cuatro letras son l, e, a, f, en ese orden, todas pequeñas. La segunda comilla cierra las letras. No hay nada más entre esas dos comillas: ni espacio, ni letra de más, ni una segunda palabra. El punto y coma termina la línea. Esta línea no escribe la pantalla. Guardar no es escribir. La pantalla sigue en blanco durante esta línea. Las comillas forman parte de la línea de guardado. Después de que la línea ha guardado las letras, no forman parte del valor que guarda el nombre.

La línea de escritura es el nombre solo: System.out.println(plant);. Sin comillas. Java lee el nombre plant, escribe las letras que ese nombre guarda, y termina la línea. Para el archivo que conservas, esas letras son l, e, a, f. Las comillas no están en la pantalla. Las letras del propio nombre, p, l, a, n, t, no están en la pantalla. String no está en la pantalla. System no está en la pantalla. El punto y coma no está en la pantalla. Guarda el archivo.

El archivo que conservas

Guarda esto como Mint.java. Es el archivo que esta página conserva. Una palabra del tipo, String. Un nombre, plant. Un par de comillas. Cuatro letras entre ellas, leaf. Una línea de escritura, y esa línea usa el nombre solo.

Léelo desde arriba. public class Mint nombra el archivo. No escribe la pantalla. public static void main(String[] args) es donde empieza Java. Ninguna de esas palabras son las letras de la pantalla. La palabra String en la línea de main sigue sin ser una línea de guardado. La línea de guardado es la posterior, String plant = "leaf";. Esa línea guarda las letras. No escribe nada. System.out.println(plant); es la única línea de escritura. Escribe leaf y termina la línea. Una línea. Sin comillas en esa línea de la pantalla.

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. Un par de comillas en el archivo no hace que javac escriba una línea, y no hace 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 el indicador del shell. El programa escribe leaf. No espera a que escribas. Las letras ya estaban en el archivo. Si java Mint espera, el archivo todavía tiene nextLine. Borra esa línea y conserva String plant = "leaf";. El programa termina después de la línea de escritura.

La pantalla muestra leaf, una línea, cuatro letras, sin comillas. Si la pantalla muestra plant, la línea de escritura tiene comillas alrededor del nombre: System.out.println("plant");. Esas comillas marcan las letras p, l, a, n, t. Java no busca el nombre, así que el leaf guardado no se escribe. El archivo que conservas tiene el nombre solo en la línea de escritura, y las comillas alrededor de leaf en la línea de guardado. Si la pantalla muestra mint, sigues en un archivo anterior. Si la pantalla muestra 4, el archivo todavía tiene el número entero de la página anterior, o las letras entre las comillas son el dígito 4. El archivo que conservas tiene leaf, no 4. No reinstalas Java porque la pantalla muestre la línea equivocada.

Una letra mayúscula entre las comillas se guarda como esa mayúscula. String plant = "Leaf"; haría que la línea de escritura escribiera Leaf, con una L grande. El archivo que conservas no usa eso. Usa cuatro letras pequeñas. Juzga la pantalla por las letras que de verdad están entre las comillas, no por una palabra que solo pensabas escribir.

Un espacio es una de las letras

La línea de escritura puede quedarse en su sitio mientras cambian las letras entre las comillas. Debajo de la primera línea de escritura, guarda un conjunto nuevo de letras en el mismo nombre, y luego escribe el nombre otra vez. La nueva línea de guardado es plant = "leaf stem";. No empieza con String. plant ya existe, así que esta línea solo sustituye las letras que guarda el nombre. Entre las comillas esta vez hay nueve lugares: l, e, a, f, un espacio, s, t, e, m. El espacio es uno de ellos. No es una ruptura en dos líneas de guardado, y no se borra cuando se escribe la pantalla. La siguiente línea de escritura es otra vez System.out.println(plant);. La pantalla tiene ahora dos líneas. La primera es leaf, de las letras que el nombre guardaba en ese momento. La segunda es leaf stem, de las letras que el nombre guarda después de plant = "leaf stem";. Un espacio queda entre leaf y stem en esa segunda línea. Las dos palabras no están en dos líneas separadas.

Este es el segundo archivo. No es el archivo que conservas. El archivo que conservas tiene una línea de guardado, las letras leaf, y ningún espacio. Guarda este segundo archivo como Mint.java cuando quieras ver el espacio, y luego vuelve a dejar la línea de guardado única y la línea de escritura única.

Escribe javac Mint.java. El archivo está bien, así que javac no escribe ninguna línea. La segunda línea de guardado puede omitir String, y esa omisión no hace fallar a javac. Luego escribe java Mint. La pantalla muestra leaf, y la línea siguiente es leaf stem. Dos líneas. Sin comillas. El nombre plant no está en ninguna de las dos líneas. Si la segunda línea es leafstem, sin hueco, falta el espacio entre las comillas. Si las dos líneas dicen leaf, falta la segunda línea de guardado o sigue diciendo "leaf". Si las dos dicen leaf stem, la primera línea de guardado ya dice "leaf stem", o la primera línea de escritura está debajo del cambio. La pantalla sigue el orden de las líneas del archivo, y sigue las letras entre las comillas, espacio incluido.

No escribas String una segunda vez para el mismo nombre. String plant = "leaf stem";, colocado bajo una línea que ya creó plant, es un error distinto. Esa línea intenta crear plant otra vez. javac escribe un error y no se queda callado. No necesitas las palabras exactas de ese error. No escribas java Mint todavía. Borra el segundo String y deja plant = "leaf stem";. El nombre se crea una vez. Las líneas posteriores solo cambian las letras que guarda. En el archivo que conservas no hay una segunda línea de guardado. Después de ver leaf y luego leaf stem, vuelve a dejar ese archivo: un String plant = "leaf"; y un System.out.println(plant);.

Nada entre las comillas

Un par puede estar vacío. String plant = ""; tiene la comilla que abre y la comilla que cierra, y ninguna letra entre ellas. La palabra del tipo sigue siendo String. El nombre sigue siendo plant. El signo = sigue guardando. Lo que guarda es ninguna letra. Esto está permitido. javac no escribe un error por un par vacío. System.out.println(plant); sigue ejecutándose. Escribe las letras que guarda el nombre, y no hay ninguna, así que la línea de la pantalla no tiene letras. La línea igual termina. El programa igual termina. Ves una línea en blanco donde habría estado leaf. Esa línea en blanco es la escritura. No es una espera, y no es un fallo de javac.

Este es el tercer archivo. No es el archivo que conservas. El archivo que conservas tiene leaf entre las comillas. Guarda este tercer archivo solo hasta que veas la línea en blanco, y luego vuelve a dejar "leaf" entre las comillas.

Escribe javac Mint.java. El par vacío está permitido, así que javac no escribe ninguna línea. Luego escribe java Mint. El programa escribe una línea sin letras y termina. No espera. Si todavía ves leaf, las comillas todavía tienen leaf entre ellas. Si java Mint espera, nextLine sigue en el archivo. Después de ver la línea en blanco, vuelve a dejar la línea de guardado como String plant = "leaf";.

Sin comillas, leaf es un nombre

El par es el que hace el trabajo. Quita las dos comillas y la línea es String plant = leaf;. No hay par, así que leaf no son letras. Java lee leaf como un nombre, y este archivo no tiene un nombre leaf. javac escribe un error. No se queda callado. No hay pantalla que leer, porque no escribes java Mint mientras javac escribe un error. No necesitas las palabras exactas del error. El dato útil es que javac escribió una línea. El arreglo es volver a poner el par, para que la línea sea otra vez String plant = "leaf";.

Una sola comilla tampoco es un par. String plant = "leaf; abre las letras y no las cierra antes del punto y coma. javac escribe un error también para esa línea. No guarda media palabra, y no adivina dónde debían terminar las letras. Vuelve a poner la comilla de cierre antes del punto y coma. El archivo que conservas tiene las dos comillas, con leaf entre ellas.

Este cuarto archivo es el par que falta. No es el archivo que conservas. Guárdalo solo hasta que javac escriba el error, y luego vuelve a poner las comillas alrededor de leaf.

Escribe javac Mint.java. javac escribe un error. No escribas java Mint. Pon una comilla antes de l y una comilla después de f, de modo que la línea sea String plant = "leaf";. Guarda. Escribe javac Mint.java otra vez. Ahora javac no escribe ninguna línea. Luego java Mint escribe leaf.

El nombre todavía tiene que existir antes de que una línea lo use. Si System.out.println(plant); está escrito encima de String plant = "leaf";, javac escribe un error. La línea de escritura nombra plant antes de que plant exista. Mueve la línea String por encima de la línea de escritura. Es el mismo orden que ya usaste para count y para reader. El archivo que conservas ya tiene ese orden.

Las letras siguen sin caber en un entero. int plant = "leaf"; pide a un nombre int que guarde letras. javac escribe un error. El arreglo en esta página no es borrar las comillas. El arreglo es conservar la palabra del tipo String, porque las comillas están guardando letras. La página anterior conservaba int y conservaba 4. Esta página conserva String y conserva "leaf".

Ya puedes guardar letras entre un par de comillas y escribir esas letras sin escribir las comillas. String plant = "leaf"; guarda leaf. System.out.println(plant); escribe leaf y termina la línea. Un plant = "leaf stem"; posterior cambia las letras guardadas sin un segundo String, y el espacio entre las comillas es una de esas letras. Un par vacío no guarda letras, y la línea de escritura escribe una línea en blanco. Sin comillas, leaf es un nombre que este archivo no tiene, y javac escribe un error. La página siguiente se queda con estas letras. Mira preguntas que puedes hacer sobre las letras que un nombre ya guarda.

La pantalla es las letras entre las comillas

El archivo que conservas escribe leaf. El nombre en la línea de escritura es plant, y plant no está en la pantalla. Las comillas están en el archivo, alrededor de leaf, y no están en la pantalla. Un println es una línea. Un espacio entre las comillas se queda en esa línea. Un par vacío escribe una línea sin letras.