La línea que escribes en Java

Quieres que la pantalla muestre una palabra que escribes después de que el programa ha empezado, una palabra que no está escrita en el archivo. En la página anterior la palabra estaba entre comillas en la línea de guardado, así que otra pantalla significaba editar Mint.java. En esta página el archivo no contiene leaf en absoluto. Crea un nombre, plant, y luego espera. Escribes leaf y pulsas Enter. La línea de escritura usa el nombre solo, y el programa escribe leaf. No instalas Java otra vez. No añades una nota, y no aprendes una segunda forma de terminar una línea. Ya sabes que un nombre puede guardar letras y que println escribe esas letras. El trabajo nuevo es llenar ese nombre con la línea que escribes.

El archivo espera una línea escrita

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 primera línea del archivo, encima de public class Mint, es import java.util.Scanner;. Esa línea deja que el archivo use Scanner. No es una línea de escritura. Scanner no es una letra para la pantalla. El punto y coma termina la línea de importación. Deja una línea en blanco debajo, y luego la misma public class Mint que ya tienes. Este archivo sigue sin una línea package. La importación es la primera línea, no una línea dentro de main.

Dentro de main, la primera línea nueva hace el lector: Scanner reader = new Scanner(System.in);. Scanner dice qué clase de cosa es reader. reader es el nombre, y empieza con una r minúscula. El signo = guarda ese lector en el nombre. new Scanner(System.in) hace el lector y lo une a System.in. System.in es el sitio del que se leen las letras que escribes. System.out, que ya usas en la línea de escritura, es la pantalla. Los dos no son lo mismo. El punto y coma termina esta línea. Esta línea no escribe la pantalla, y no espera a que escribas. Solo hace reader.

La línea siguiente llena el nombre que ya conoces de la página anterior: String plant = reader.nextLine();. String sigue queriendo decir que este nombre guarda letras. plant sigue empezando con una p minúscula. El signo = sigue guardando letras en ese nombre. Lo nuevo es el lado derecho. reader.nextLine() no tiene comillas. En esta línea no hay leaf. La línea pide a reader una línea escrita. El programa espera ahí hasta que pulsas Enter. Cuando pulsas Enter, nextLine guarda las letras que escribiste antes de ese Enter. No guarda la tecla Enter. Luego la línea termina en el punto y coma. Guardar sigue sin ser escribir. El programa todavía no ha escrito su propia línea.

La línea de escritura sigue siendo el nombre solo, con la misma forma que en el archivo que conservaste en la página anterior: System.out.println(plant);. Sin comillas. Java lee el nombre plant, escribe las letras que ese nombre guarda y termina la línea. Esas letras son lo que nextLine acaba de guardar. Si escribiste leaf, el programa escribe leaf. Si escribiste stem, el programa escribe stem. El archivo no cambió entre las dos ejecuciones. Guarda el archivo.

El archivo que conservas

Guarda esto como Mint.java. Este es el archivo que conserva esta página. La palabra que vas a escribir no está en el archivo. Busca en el archivo las letras l, e, a y f. No están. El lector se llama reader. La línea guardada se llama plant. La línea de escritura usa plant y no contiene comillas.

Lee el archivo desde arriba y decide qué puede llegar a la pantalla. import java.util.Scanner; solo deja que el archivo use Scanner. public class Mint nombra el archivo. public static void main(String[] args) es el sitio donde Java empieza. Ninguna de esas palabras es una letra para la pantalla. La palabra String de la línea main no es el String que crea plant. Scanner reader = new Scanner(System.in); hace el lector reader. No escribe nada. String plant = reader.nextLine(); guarda una línea escrita en plant. Por sí sola no escribe nada. System.out.println(plant); es la única línea de escritura. Escribe las letras guardadas y termina la línea. El nombre plant no se escribe. El nombre reader no se escribe. System no se escribe. El punto y coma no se escribe.

Lo que escribes y lo que escribe el programa

En la carpeta que contiene este Mint.java, escribe javac Mint.java. Cuando el archivo está bien, este comando no escribe ninguna línea. Una línea de importación y un reader no hacen que javac escriba una línea, ni hacen que falle. Luego escribe java Mint. No escribas .java después de java. Esos 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. Esas marcas difieren, y no son la línea del programa.

Después de java Mint, el programa espera en reader.nextLine(). No ha terminado, y no ha escrito leaf, porque todavía no le has dado una línea. El cursor está en una línea nueva. Escribe las letras l, e, a y f. La terminal muestra esas letras mientras pulsas las teclas. Esa muestra es la terminal repitiendo tus teclas. No es System.out.println. Luego pulsa Enter.

Enter termina la espera. nextLine guarda la palabra leaf en plant y no guarda Enter. Después println escribe leaf y termina la línea. Ves leaf, y debajo leaf otra vez. El primer leaf son las teclas que mostró la terminal. El segundo leaf es el programa. La línea del programa no tiene comillas. Son cuatro letras, y luego termina la línea. El programa termina después de esa línea de escritura. Si solo quieres juzgar la línea del programa, mira la línea que aparece después de pulsar Enter.

Si la línea del programa es plant, la línea de escritura tiene comillas alrededor de plant. El archivo que conservas no las tiene. Si la línea del programa es mint, la línea de escritura sigue siendo System.out.println("mint");, o el archivo sigue guardando una palabra entre comillas de una página anterior. Si java Mint escribe leaf de inmediato y nunca espera, el archivo sigue guardando una palabra entre comillas, como String plant = "leaf";, y no usa nextLine. Busca comillas alrededor de leaf. El archivo que conservas no las tiene. No vuelvas a instalar Java porque la pantalla muestre la palabra equivocada.

Las mayúsculas se copian tal como las escribes. Si escribes Leaf con L mayúscula y pulsas Enter, la línea del programa es Leaf. El archivo sigue sin contener esas letras. Un Enter vacío también es una línea de verdad. Pulsa Enter sin escribir letras. nextLine no guarda ninguna letra en plant. println escribe una línea sin letras. El programa se ejecutó. La espera terminó porque pulsaste Enter. El archivo que conservas es el que pruebas con leaf, cuatro letras minúsculas.

Un espacio se queda en la línea

nextLine lee hasta Enter, no hasta un espacio. Escribe leaf, luego un espacio, luego stem, y luego Enter. Las letras guardadas en plant son leaf, un espacio y stem. System.out.println(plant) escribe leaf stem. El espacio es un carácter guardado, igual que en la página anterior se guardaba un espacio dentro de las comillas. Esta página no corta la línea en el espacio. El archivo que conservas sigue leyendo una sola línea. Cuando quieres el espacio en la pantalla, solo cambias lo que escribes, no el archivo.

Dos líneas escritas, dos Enter

Un solo reader puede tomar una segunda línea. Debajo de la primera línea de escritura, guarda una línea nueva en el mismo nombre y luego escribe el nombre otra vez. La nueva línea de guardado es plant = reader.nextLine();. No empieza con String. plant ya existe, así que esta línea solo sustituye las letras que el nombre guarda. La siguiente línea de escritura es otra vez System.out.println(plant);. El programa ahora espera dos veces. Cada nextLine espera su propio Enter.

Este es el segundo archivo. No es el archivo que conservas. El archivo que conservas espera una vez y escribe una vez. Guarda este segundo archivo como Mint.java cuando quieras dos líneas escritas, y luego vuelve a poner el único nextLine y el único println.

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 que javac falle. Luego escribe java Mint. El programa espera. Escribe leaf y pulsa Enter. La terminal muestra leaf, y el programa escribe leaf debajo. El programa espera otra vez. No ha terminado. Escribe stem y pulsa Enter. La terminal muestra stem, y el programa escribe stem debajo. Las líneas del programa son leaf, y luego stem. Las letras que la terminal mostró desde las teclas quedan encima de cada una de esas líneas. Si las dos líneas del programa dicen leaf, el segundo nextLine no se ejecutó, o escribiste leaf las dos veces. Si el programa escribe stem antes de que hayas escrito una segunda línea, el segundo println no está debajo de un segundo nextLine. La pantalla sigue el orden de las líneas del archivo, y cada espera sigue al nextLine que todavía no ha recibido Enter.

No escribas String una segunda vez para el mismo nombre. String plant = reader.nextLine();, debajo de una línea que ya creó plant, es otro error. Esa línea intenta crear plant otra vez. javac escribe un error y no se queda en silencio. No necesitas las palabras exactas de ese error. El dato útil es que javac escribió una línea, así que todavía no escribes java Mint. Borra el segundo String y deja plant = reader.nextLine();. El nombre se crea una vez. Las líneas posteriores solo cambian las letras que guarda. En el archivo que conservas no hay un segundo nextLine. Después de ver leaf y luego stem, vuelve a poner el archivo de una sola línea.

La línea de importación está encima de public class

El archivo no conoce Scanner hasta que está la línea de importación. Si borras import java.util.Scanner; y dejas el resto del archivo que conservas, javac escribe un error. No se queda en silencio. No hay pantalla que leer, porque no escribes java Mint mientras javac escribe un error. No necesitas las palabras exactas del error. La reparación es volver a poner import java.util.Scanner; como primera línea, encima de public class Mint, con su punto y coma. Guarda, escribe javac Mint.java otra vez, y espera hasta que javac no escriba ninguna línea.

Este tercer archivo no tiene la importación. No es el archivo que conservas. Guárdalo solo hasta que javac escriba el error, y luego vuelve a poner la línea de importación.

La línea de importación también falla si la metes dentro de main, bajo la llave de apertura, o si la pones debajo de public class. Java lee una importación encima de public class, no como un paso dentro de main. Vuelve a ponerla en la primera línea. Un punto y coma que falta en esa línea es el mismo tipo de fallo: javac escribe un error, y no ejecutas java Mint. El archivo que conservas tiene el punto y coma.

System.in es el único sitio al que esta página une el lector. Scanner reader = new Scanner(System.out); pide un lector en la pantalla. System.out es adonde escribe println. No es el sitio del que se leen las letras escritas. javac escribe un error. No se queda en silencio. No escribas java Mint. Cambia System.out por System.in en esa sola línea. La línea de escritura se queda con System.out, porque la línea de escritura es la pantalla. La línea de reader se queda con System.in, porque la línea de reader es el teclado. Mezclarlos es el error.

Este cuarto archivo une el lector a la pantalla. No es el archivo que conservas. Guárdalo solo hasta que javac escriba el error, y luego cambia out por in.

reader tiene que existir primero

Java lee el archivo desde arriba. La línea que hace reader tiene que estar encima de la línea que usa reader. Si String plant = reader.nextLine(); va primero, y solo después Scanner reader = new Scanner(System.in);, la línea de guardado usa el nombre reader antes de que reader exista. javac escribe un error. No se queda en silencio. Es la misma regla de orden que en la página anterior, cuando plant se usó antes de String plant. La reparación es mover la línea Scanner encima de la línea nextLine. Un nombre no se usa en una línea anterior a la línea que lo crea.

Este quinto archivo tiene el orden roto. No es el archivo que conservas. Guárdalo solo hasta que javac escriba el error, y luego vuelve a poner la línea Scanner encima de nextLine. La línea de importación sigue haciendo falta en un archivo que de verdad ejecutas. Este archivo roto conserva la importación para que el único error nuevo sea el orden.

Escribe javac Mint.java. javac escribe un error. No escribas java Mint. Mueve Scanner reader = new Scanner(System.in); encima de String plant = reader.nextLine();. Guarda. Escribe javac Mint.java otra vez. Ahora javac no escribe ninguna línea. Luego java Mint espera. Escribe leaf, pulsa Enter, y el programa escribe leaf.

Las comillas en la línea de escritura siguen significando lo mismo que en la página anterior. Después de un nextLine de verdad, si la línea de escritura es System.out.println("plant");, puedes escribir leaf y pulsar Enter, y la línea del programa sigue siendo plant. Las comillas marcan las letras p, l, a, n y t. Java no busca el nombre. La línea que escribiste se guardó en plant y no se escribió. La reparación es el nombre solo, System.out.println(plant);. El archivo que conservas ya tiene ese nombre solo. Tampoco pongas comillas alrededor de leaf en la línea de guardado. String plant = "leaf"; guardaría leaf desde el propio archivo y nunca esperaría. Esta página deja nextLine en la línea de guardado y deja la línea de escritura sola.

Ahora puedes ejecutar Mint.java, esperar, escribir una línea, pulsar Enter y ver que el programa escribe esa línea. import java.util.Scanner; está encima de public class. Scanner reader = new Scanner(System.in); hace el lector en el teclado. String plant = reader.nextLine(); guarda la línea, sin el Enter. System.out.println(plant); la escribe y termina la línea. Un plant = reader.nextLine(); posterior espera un segundo Enter. La importación, System.in y el hecho de que reader exista antes de usarse son lo que deja a javac en silencio. La página siguiente deja el teclado. Mira clases de valores que un nombre puede guardar cuando escribes esos valores en el archivo, y empieza por los números, no por una línea que escribes.

La pantalla es la línea que escribiste

El archivo que conservas no contiene leaf. Escribes leaf después de java Mint y pulsas Enter. La terminal muestra esa escritura. Luego el programa escribe leaf en la línea siguiente. Un espacio que escribes forma parte de esa línea. Un segundo nextLine es un segundo Enter, y no está en el archivo que conservas.