Dos palabras, true o false en Java

boolean ripe = true; guarda la palabra true, y System.out.println(ripe) escribe true. La pantalla es una línea. No hay comillas alrededor de true, y no hay ningún dígito en esa línea.

La palabra que escribes es true o false

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 int count si esa línea sigue ahí, incluido 40, -4 y 040. Borra String plant si sigue ahí. Borra plant.length, borra charAt, y borra cada línea que hace una pregunta después de un punto. 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 plant, no tiene count y no tiene ningún dígito. Un import que no se usa no hace fallar a javac por sí solo, y tampoco escribe true. La palabra la escribe solo la línea de escritura que usa el nombre.

Dentro de main, la línea de guardado es boolean ripe = true;. boolean es la palabra de tipo. Dice que este nombre guarda una de dos palabras, true o false, y nada más. ripe es el nombre, y empieza con una r minúscula. El signo = guarda la palabra. La palabra es true, todas las letras minúsculas: t, r, u, e. No hay una T mayúscula. No hay comillas alrededor de true. No hay ningún dígito. El punto y coma termina la línea. Esta línea guarda la palabra. No escribe la pantalla. Guardar no es escribir. La pantalla sigue en blanco durante esta línea. true no es un atajo para escribir el número 1. false no es un atajo para escribir 0. Esos dígitos eran de la página del número. Esta página no los guarda.

Este tipo son solo esas dos palabras. No inventes una tercera. boolean ripe = yes; trata yes como un nombre. Este archivo no tiene un nombre yes. javac escribe un error. boolean ripe = no; hace lo mismo. Las palabras que puedes escribir, con esta palabra de tipo y sin comillas, son true y false. El archivo que guardas usa true.

La línea de escritura es el nombre solo: System.out.println(ripe);. Sin comillas y sin punto. Java lee el nombre ripe, escribe la palabra que ese nombre guarda, y termina la línea. Para el archivo que guardas, esa palabra es true. Las letras del propio nombre, r, i, p, e, no están en la pantalla. boolean no está en la pantalla. System no está en la pantalla. El punto y coma no está en la pantalla. La palabra true 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 de tipo, boolean. Un nombre, ripe. Una palabra, true, todo en minúsculas, sin comillas, sin dígito. 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 Java empieza. La palabra String en esa línea main sigue sin ser una línea de guardado. En el archivo que guardas no hay una línea String plant, y no hay una línea int. boolean ripe = true; guarda la palabra. No escribe nada. System.out.println(ripe); escribe true y termina la línea. En la pantalla hay una línea. Sin comillas. Sin segunda línea.

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. La palabra true después de boolean 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 signo que el shell muestra antes del comando. El programa escribe true. No espera a que escribas algo. La palabra ya estaba en el archivo. Si java Mint espera, nextLine sigue en el archivo. Borra esa línea y deja boolean ripe = true; y la única línea de escritura. El programa termina después de la línea de escritura.

La pantalla muestra true. Una línea. Sin comillas. Si la pantalla muestra ripe, la línea de escritura tiene comillas alrededor del nombre: System.out.println("ripe");. Esas comillas marcan las letras r, i, p, e, así que la palabra guardada no se escribe. Si la pantalla muestra 40, o 4, o -4, o 32, el archivo de los números sigue en su sitio. Borra la línea int. El archivo que guardas no tiene ningún dígito. Si la pantalla muestra leaf, plant sigue en el archivo. Si la pantalla muestra mint, sigues en un archivo más viejo. Si la pantalla muestra false, la línea de guardado dice false, que es la otra palabra, no el archivo que guardas. No vuelvas a instalar Java porque la pantalla muestra la línea equivocada.

Una pantalla que muestra true no prueba el tipo por sí sola. System.out.println("true"); sin ninguna línea boolean también escribiría true, porque las comillas guardan las letras t, r, u, e. La pantalla puede verse igual. El archivo no. El archivo que guardas tiene boolean, y tiene true sin comillas. Cuando juzgas esta página, busca la palabra de tipo y la ausencia de comillas. No juzgues el tipo solo por la pantalla.

Las comillas alrededor de la palabra son letras, no este tipo. boolean ripe = "true"; pide a un nombre boolean que guarde letras. javac escribe un error. No convierte esas letras en la palabra true. No se queda callado. No hay pantalla que leer, porque no escribes java Mint mientras javac escribe un error. No necesitas el texto exacto de ese error. Borra las comillas para que la línea vuelva a ser boolean ripe = true;. El mismo desajuste es boolean ripe = "false";. Las comillas hacen letras. Este tipo no guarda letras.

El nombre tiene que existir antes de que una línea lo use. Si System.out.println(ripe); está escrito encima de boolean ripe = true;, javac escribe un error. La línea de escritura nombra ripe antes de que ripe exista. Mueve la línea de guardado por encima de la línea de escritura. Es el mismo orden que count en la página del número y que plant en las páginas de las letras. El archivo que guardas ya tiene ese orden. No escribas boolean una segunda vez para el mismo nombre. boolean ripe = false; colocado debajo de una línea que ya creó ripe es otro error. javac escribe un error y no se queda callado. El nombre se crea una vez. El archivo que guardas tiene una línea de guardado.

boolean ripe; sin = true, seguido de la línea de escritura, hace que javac escriba un error. El nombre existiría como tipo, y todavía no guardaría ninguna palabra. Pon = true en la línea que crea el nombre, como lo tiene el archivo que guardas. boolean ripe = truefalse; trata truefalse como un solo nombre. Este archivo no tiene ese nombre. javac escribe un error. La palabra es true, y un espacio o la falta de un espacio no inventa una tercera palabra. boolean ripe = true ; con un espacio antes del punto y coma sigue siendo la palabra true. javac no escribe ninguna línea, y la pantalla sigue siendo true. El archivo que guardas no tiene ese espacio de más, pero ese espacio no es un segundo valor.

La otra palabra es false

false es la otra palabra que guarda este tipo. No es un segundo tipo. La palabra de tipo sigue siendo boolean. El nombre puede seguir siendo ripe. Solo cambia la palabra guardada. boolean ripe = false; guarda false, todas las letras minúsculas: f, a, l, s, e. Sin comillas. Sin dígito. La línea de escritura sigue siendo System.out.println(ripe);. La pantalla muestra false. Una línea. El nombre ripe no está en la pantalla. Esto no es un recuento de letras, y no es el número 0.

Este es el segundo archivo. No es el archivo que guardas. El archivo que guardas guarda true, y su pantalla es true. Guarda este segundo archivo como Mint.java cuando quieras ver false, y luego vuelve a poner boolean ripe = true;.

Escribe javac Mint.java. El archivo está bien, así que javac no escribe ninguna línea. La palabra false después de boolean no hace fallar a javac. Luego escribe java Mint. La pantalla muestra false. Una línea. Sin comillas. Si la pantalla muestra true, la línea de guardado todavía dice true, que es el archivo que guardas. Si la pantalla muestra 0, todavía hay una línea int en el archivo. Si la pantalla muestra ripe, la línea de escritura tiene comillas alrededor del nombre. Una línea posterior puede cambiar la palabra sin escribir boolean otra vez, una vez que ripe ya existe: ripe = false;. Esa línea solo sustituye la palabra que el nombre guarda. Está permitido. No hace falta para el archivo que guardas, y no es este segundo archivo. El segundo archivo guarda false en la línea que crea el nombre. No escribas boolean en esa línea posterior. Después de ver false, vuelve a poner el archivo que guardas: boolean ripe = true; y un System.out.println(ripe);.

Una letra mayúscula no es la palabra. boolean ripe = True; trata True como un nombre, porque la primera letra es una T mayúscula. Este archivo no tiene un nombre True. javac escribe un error. No se queda callado. La pantalla no muestra True, porque no ejecutas java Mint mientras javac escribe un error. La palabra en el archivo que guardas es true, todo en minúsculas. boolean ripe = False; es el mismo error para la otra palabra. False es un nombre que este archivo no tiene. La palabra es false, todo en minúsculas. Vuelve a poner las letras minúsculas.

Un dígito no cabe

Un dígito es un número entero, el tipo de la página del número. boolean ripe = 1; pide a este tipo que guarde el número 1. Ese número no cabe. javac escribe un error. No convierte 1 en true. boolean ripe = 0; no convierte 0 en false. javac escribe un error también para esa línea. boolean ripe = 40; es el mismo desajuste, un número entero en un nombre que solo guarda true o false. Cuando arreglas el archivo que guardas, borra los dígitos y escribe true, sin comillas. No necesitas el texto exacto de estos errores. Cada uno es una línea de javac, así que no ejecutes java Mint hasta que la línea de guardado vuelva a ser boolean ripe = true; y javac no escriba ninguna línea.

int count = true; es el desajuste al revés. int guarda un número entero. true no es un dígito que puedas guardar bajo int. javac escribe un error. El archivo que guardas no usa int en absoluto. Si las dos líneas están en el archivo, boolean ripe = true; e int count = 40;, cada nombre tiene su propio tipo, y cada línea de escritura muestra su propio valor. Eso está permitido. No es el archivo que guardas. El archivo que guardas es un nombre, ripe, y una palabra, true. Dos tipos en un archivo ya fue el trabajo de una página anterior. Aquí la prueba es la palabra true en la pantalla, desde boolean, sin un dígito al lado.

Ahora puedes guardar una de dos palabras en un nombre y escribir esa palabra sin comillas y sin dígito. boolean ripe = true; guarda true. System.out.println(ripe); escribe true y termina la línea. boolean ripe = false; escribe false, y esa es la otra palabra, no un segundo tipo. Las comillas alrededor de la palabra, un dígito y una T mayúscula hacen que javac escriba un error. La página siguiente deja estas dos palabras. Vuelve a mirar un número entero que escribes en el archivo, y una palabra de tipo que todavía no coincide con ese valor.

La pantalla es la palabra que guardaste

El archivo que guardas escribe true. El nombre en la línea de escritura es ripe, y ripe no está en la pantalla. En ese archivo no hay comillas. Un println es una línea. false, cuando usas el segundo archivo, es la otra palabra de esa línea. Un dígito no tiene sitio en el archivo que guardas.