Salida de Java

Quieres que la pantalla muestre una palabra distinta. El archivo sigue siendo Mint.java, y la orden que escribe sigue siendo la línea que ya conoces. En la página anterior las comillas contenían mint, así que la pantalla era mint. En esta página pones otra palabra entre esas comillas, luego añades una segunda línea que escribe, y después ves qué muestra la pantalla cuando una línea que escribe no termina la línea. No estás instalando Java otra vez. No estás buscando qué línea escribe la pantalla, y no estás añadiendo una nota. Ya conoces la línea que escribe, y ya sabes que una nota no está en la pantalla. El trabajo nuevo son las letras que muestra la pantalla.

La palabra entre las comillas

Abre Mint.java y busca la línea System.out.println("mint");. La pantalla muestra la palabra que está entre las comillas. Las comillas mismas no son letras para la pantalla. Marcan dónde empieza esa palabra y dónde acaba. Cambia la palabra. Deja el resto de la línea como está: System.out.println se queda, la comilla de apertura se queda, la comilla de cierre se queda, y el punto y coma se queda. Solo cambian las letras que están entre las comillas. Donde el archivo tenía mint, escribe leaf, todo en minúsculas. La línea ahora es System.out.println("leaf");. Guarda el archivo. El nombre del archivo sigue siendo Mint.java, porque la línea public class Mint sigue siendo el nombre del archivo. Esta página no cambia el nombre del archivo.

El archivo que conservas

Guarda esto como Mint.java. Es el archivo que esta página conserva. Tiene una línea que escribe, y esa línea guarda leaf entre las comillas. En este archivo no hay nota. Todavía no hay una segunda línea que escribe.

Léelo desde arriba y decide qué puede recibir la pantalla. La primera línea es public class Mint. Esa línea nombra el archivo. No escribe la pantalla, y tampoco la escribió en las páginas anteriores. La línea siguiente es public static void main(String[] args). Ahí empieza Java. Ninguna de esas palabras es una letra para la pantalla. Dentro de main hay una orden: System.out.println("leaf");. System.out.println es la orden que escribe. Las comillas guardan leaf. El punto y coma termina la orden. Java ejecuta esa orden porque está dentro de main y no está detrás de //. La pantalla muestra leaf. No muestra las comillas, ni el punto y coma, ni la palabra System, ni la palabra main.

Ejecútalo igual que antes. En la carpeta que contiene este Mint.java, escribe javac Mint.java. Cuando el archivo está bien, esa orden no escribe ninguna línea. Una palabra distinta entre las comillas no hace que javac escriba una línea, ni hace que falle. Después escribe java Mint. No escribas .java después de java. La pantalla muestra leaf. Una línea. Sin comillas. Sin punto y coma. La palabra mint no está en la pantalla, porque mint ya no está entre las comillas. Si la pantalla sigue mostrando mint, las comillas siguen conteniendo mint. Mira las letras que están entre las comillas antes de escribir las órdenes otra vez. No vuelves a instalar Java porque la pantalla siga diciendo mint.

La pantalla muestra las letras que están entre las comillas tal como están. System.out.println("Leaf"); escribe Leaf, con L mayúscula. System.out.println("leaf"); escribe leaf, con l minúscula. El archivo que conservas usa la l minúscula, así que su pantalla es leaf y no Leaf. Un espacio también es una letra que la pantalla puede mostrar, si escribes el espacio dentro de las comillas. System.out.println("leaf stem"); escribe una línea: leaf stem, con el espacio que pusiste entre las dos palabras. Las comillas tampoco se ven aquí. Esta es una línea que escribe, así que es una línea de pantalla, aunque dentro haya dos palabras. Un par de comillas vacío es distinto. System.out.println(""); escribe una línea que no tiene letras, y luego termina esa línea. La pantalla se ve en blanco. La orden sí se ejecutó. Las comillas simplemente no guardaban nada. Esa línea en blanco no es el archivo que conservas. El archivo que conservas guarda leaf.

Una segunda línea

Una línea que escribe da una línea de pantalla. Una segunda línea de pantalla necesita una segunda línea que escribe. Debajo de System.out.println("leaf"); añade System.out.println("stem");. Cada orden tiene sus propias comillas y su propio punto y coma. leaf se queda en el primer par. stem, todo en minúsculas, va en el segundo par. Java ejecuta la primera orden, termina esa línea, luego ejecuta la segunda orden y termina también esa línea. El orden de la pantalla es el orden del archivo. La orden que escribiste primero es la línea que la pantalla muestra primero.

Este es el segundo archivo. Estás mirando dos líneas de pantalla. El archivo que conservabas tenía una línea que escribe y la pantalla era leaf. Este tiene dos líneas que escriben. Guárdalo como Mint.java cuando quieras ver esta pantalla, y vuelve a dejar una sola línea que escribe si quieres el archivo que esta página conserva.

En la misma carpeta escribe javac Mint.java. El archivo está bien, así que javac no escribe ninguna línea. Después escribe java Mint. La pantalla muestra leaf, y la línea siguiente de la pantalla es stem. Dos líneas. leaf está arriba porque System.out.println("leaf"); es la primera orden que escribe. stem está debajo porque System.out.println("stem"); es la segunda. Las comillas no están en ninguna de las dos líneas. Si stem está arriba y leaf debajo, las dos líneas que escriben han cambiado de sitio en el archivo. La pantalla no elige un orden propio. Vuelve a poner la orden de stem debajo de la orden de leaf, guarda, y ejecuta java Mint otra vez. No necesitas un tipo nuevo de orden para conseguir la segunda línea. Necesitas un segundo System.out.println, con su propia palabra entre sus propias comillas.

print no termina la línea

Mira el final de la orden que escribe que has estado usando. println acaba con las letras ln. Esas letras son el final de la línea. La orden escribe las letras que están entre las comillas y luego termina la línea, así que la siguiente orden que escribe empieza en una línea nueva. print es la misma orden que escribe, sin esas dos letras. System.out.print("leaf"); escribe leaf y no termina la línea. El siguiente System.out.print empieza donde acabó esa palabra. La orden no pone un espacio por ti. Si el primer par guarda leaf y el segundo guarda stem, y ninguno de los dos pares guarda un espacio, la pantalla muestra leafstem en una sola línea.

Este es el tercer archivo. No es el archivo que conservas. Guárdalo solo hasta ver la línea única leafstem. Las dos órdenes son print, no println. No hay un espacio dentro de ninguno de los dos pares.

Escribe javac Mint.java. El archivo está bien, así que javac no escribe ninguna línea. print es una orden de verdad. Usarla no hace que javac falle. Después escribe java Mint. La pantalla muestra leafstem. Una línea. No hay espacio entre leaf y stem. No hay comillas. leaf sigue primero, porque System.out.print("leaf"); es la primera orden, y stem se escribe justo después, porque System.out.print("stem"); no empieza una línea nueva. Si ves leaf y después stem en una segunda línea, las órdenes del archivo son println, no print. Las letras ln siguen en la orden, así que cada orden terminó su línea. Si la pantalla que quieres es la palabra única leafstem, quita las letras ln de las dos órdenes.

El programa escribe leafstem y termina sin acabar la línea. La terminal puede dibujar su propia marca en esa misma línea, después de leafstem. Esa marca es de la terminal. No es una palabra de Mint.java, y no forma parte de la línea que estás comprobando. Comprueba las letras que están entre las comillas: leafstem. No intentes igualar la marca de la terminal. Windows y macOS dibujan marcas distintas, y esta página no enseña esas marcas. La línea del programa es la misma en los dos: leafstem, y después no hay final de línea.

Un espacio tiene que estar dentro de las comillas

Si quieres un espacio en esa misma línea, el espacio tiene que ser una de las letras que están entre las comillas. La orden que escribe no lo inventa. Cambia la primera orden a System.out.print("leaf "); con un espacio después de la f, todavía dentro de las comillas. Deja la segunda orden como System.out.print("stem");. Java escribe primero leaf, luego escribe el espacio que pusiste después de la f, luego escribe stem, y sigue sin terminar la línea. La pantalla muestra leaf stem. El espacio que ves es el espacio que estaba dentro del primer par. Un espacio que escribes fuera de las comillas, entre las dos órdenes, es solo un hueco en el archivo. No es una letra para la pantalla. Puedes poner las dos órdenes en dos líneas del archivo, o poner una línea en blanco entre ellas, y la pantalla sigue siendo una línea. Un salto de línea en el archivo no es un final de línea en la pantalla. Solo la orden que termina la línea, println, termina una línea de pantalla. print no lo hace nunca, sea como sea el espacio alrededor de las órdenes en el archivo.

Cuando termines de mirar leafstem y leaf stem, vuelve a dejar el archivo en el que conservas. La línea que escribe en el archivo que conservas es System.out.println("leaf"); y no hay una segunda línea que escribe. Entonces java Mint vuelve a mostrar leaf, una línea, y la línea sí termina. Si dejas un print en el archivo por error, la siguiente ejecución no termina esa línea. La comprobación son las letras de la orden: println termina la línea, print no.

El error que quita las comillas

La palabra que muestra la pantalla tiene que estar entre comillas. El error es borrar las comillas y dejar la palabra sola: System.out.println(leaf);. leaf sin comillas no es una palabra para la pantalla. Java la lee como un nombre, y este archivo no tiene ese nombre. La página siguiente trata de los nombres. Esta página se queda en las comillas. Guarda este cuarto archivo solo hasta ver que javac no se queda callado, y luego vuelve a poner las comillas. Este no es el archivo que conservas.

Escribe javac Mint.java. Esta vez javac escribe un error. No se queda callado. El archivo no está bien, porque leaf no tiene comillas y todavía no tiene significado en este archivo. No necesitas las palabras exactas de ese error. El dato útil es que javac escribió una línea. Cuando javac escribe un error, no escribas java Mint. No hay una pantalla nueva que leer hasta que el archivo vuelva a estar bien. Vuelve a poner las comillas, de modo que la línea sea otra vez System.out.println("leaf");. Guarda. Escribe javac Mint.java una vez más. Ahora javac no escribe ninguna línea. Después java Mint muestra leaf. Toda la reparación fueron las comillas. No vuelves a instalar Java, y no quitas la línea que escribe. Una línea que escribe sin sus comillas no es una pantalla en blanco causada por una nota. Una nota habría dejado a javac callado. Este error hace que javac escriba una línea.

Ya puedes cambiar la pantalla cambiando las letras que están entre las comillas. System.out.println("leaf"); escribe leaf y termina la línea. Un segundo System.out.println escribe la línea siguiente, en el orden en que escribiste las órdenes en el archivo. System.out.print escribe sus letras y no termina la línea, así que el print siguiente sigue en esa misma línea, y un espacio solo se ve cuando lo pones dentro de las comillas. Si javac escribe un error ante una palabra sola, faltan las comillas. La página siguiente le da un nombre a una palabra, para que una línea que escribe pueda usar ese nombre y no solo una palabra entre comillas.

La pantalla es la palabra entre las comillas

El archivo que conservas escribe leaf. Un println es una línea. Dos órdenes println son dos líneas, la primera orden primero. Dos órdenes print son una línea, y leafstem no tiene espacio porque ninguno de los dos pares guardaba un espacio. Las comillas, el punto y coma y el nombre del archivo se quedan fuera de la pantalla.