Dos dígitos, un número en Java

int count = 40; guarda dos dígitos como un número entero, y System.out.println(count) escribe 40. La pantalla es una línea. El 4 no es un recuento de letras. El 0 no es un segundo número al lado.

Los dígitos que escribes son un número

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 si esa línea todavía está. Borra plant.length, borra charAt y borra cada línea que hace una pregunta después de un punto. Borra cualquier línea de import, cualquier línea de reader y cualquier línea de nextLine. El archivo que guardas no tiene import, ni Scanner, ni nextLine, ni plant, ni punto. Un import sin uso no hace fallar a javac por sí solo, y tampoco escribe 40. Los dígitos los escribe solo la línea de escritura que usa el nombre.

Dentro de main, la línea de guardado es int count = 40;. int es la palabra del tipo. Dice que este nombre guarda un número entero. count es el nombre, y empieza con una c minúscula. El signo = guarda los dígitos. Los dígitos son 4 y luego 0, y entre ellos no hay nada: ni espacio, ni coma, ni punto, ni comillas. El punto y coma termina la línea. Esta línea guarda el número. No escribe la pantalla. Guardar no es escribir. La pantalla sigue en blanco durante esta línea. Los dos dígitos son un número, cuarenta escrito como 40, no la palabra forty, y no un 4 al que luego sigue un 0 aparte.

El 4 de la página del recuento de letras era una respuesta. plant.length() miraba leaf y la línea de escritura mostraba 4, mientras las letras seguían siendo leaf. Ese 4 no estaba escrito como dígitos en una línea de guardado. Esta página deja esa pregunta. No hay un plant que contar. El 4 dentro de 40 es un dígito que escribiste tú, y el 0 de al lado es el otro dígito del mismo número. Si la pantalla muestra leaf, o leaf y luego 4, las líneas viejas siguen en el archivo. Bórralas hasta que el único valor guardado sea 40.

La línea de escritura es el nombre solo: System.out.println(count);. Sin comillas y sin punto. Java lee el nombre count, escribe el número entero que ese nombre guarda y termina la línea. Para el archivo que guardas, ese número es 40. Las letras del propio nombre, c, o, u, n, t, no están en la pantalla. int no está en la pantalla. System no está en la pantalla. El punto y coma no está en la pantalla. Los dígitos 4 y 0 están en la pantalla, en una línea, 40. Guarda el archivo.

El archivo que guardas

Guarda esto como Mint.java. Es el archivo que esta página guarda. Una palabra del tipo, int. Un nombre, count. Un número entero, 40, dos dígitos, sin comillas, sin punto, sin espacio entre los dígitos y sin signo menos. 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 de main sigue sin ser una línea de guardado. En el archivo que guardas no hay una línea String plant. int count = 40; guarda los dos dígitos. No escribe nada. System.out.println(count); escribe 40 y termina la línea. Una línea en la pantalla. Sin comillas. Sin segunda línea.

Qué 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. Dos dígitos sin espacio entre ellos no hacen que javac escriba una línea, ni hacen que javac falle. Luego escribe java Mint. No escribas .java después de java. Son los mismos dos comandos que escribes en Windows y en macOS. Esta página no cita el aviso del shell. El programa escribe 40. No espera a que escribas. Los dígitos ya estaban en el archivo. Si java Mint espera, nextLine sigue en el archivo. Borra esa línea y deja int count = 40; y la única línea de escritura. El programa termina después de la línea de escritura.

La pantalla muestra 40. Una línea. Sin comillas. Si la pantalla muestra count, la línea de escritura tiene comillas alrededor del nombre: System.out.println("count");. Esas comillas marcan las letras c, o, u, n, t, así que el 40 guardado no se escribe. Si la pantalla muestra 4, la línea de guardado es int count = 4;, un dígito, o el archivo sigue siendo la página del recuento de letras y la línea de escritura es plant.length(). El archivo que guardas tiene 40, dos dígitos. Si la pantalla muestra 4 y luego 0 en la línea siguiente, hay dos líneas de escritura, o dos números. El archivo que guardas tiene una línea de escritura y un número. Si la pantalla muestra 400, hay un 0 de más en la línea de guardado. 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 forty, la línea de escritura tiene la palabra forty entre comillas. El archivo que guardas escribe dígitos, no esa palabra. No vuelves a instalar Java porque la pantalla muestre la línea equivocada.

Un espacio entre los dígitos no es un número. int count = 4 0; tiene un hueco entre 4 y 0. 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 de ese error. Borra el hueco para que la línea vuelva a ser int count = 40;. Una coma no es una marca de millares en esta página. int count = 4,000; no es el número 4000. javac escribe un error. El archivo que guardas no tiene coma. Un punto sigue sin ser un número entero para int. int count = 40.0; hace que javac escriba un error, el mismo desajuste que un punto en un número más pequeño. El archivo que guardas tiene 40, sin punto y sin un dígito después de un punto.

Las comillas alrededor de los dígitos son letras, no el número entero. int count = "40"; pide a un nombre int que guarde dos letras de dígito. javac escribe un error. No convierte esas letras en el número 40. Borra las comillas si la palabra del tipo es int. System.out.println("40"); sin ninguna línea int también escribiría 40, porque las comillas guardan los caracteres 4 y 0. La pantalla puede verse igual. El archivo no. El archivo que guardas tiene int, y tiene 40 sin comillas. Cuando juzgas esta página, busca la palabra del tipo y la ausencia de comillas. No juzgues el tipo solo por la pantalla.

El nombre tiene que existir antes de la línea que lo usa. Si System.out.println(count); está escrito encima de int count = 40;, javac escribe un error. La línea de escritura nombra count antes de que count exista. Mueve la línea de guardado por encima de la línea de escritura. Es el mismo orden que la página anterior del número entero y que plant en las páginas de letras. El archivo que guardas ya tiene ese orden. No escribas int una segunda vez para el mismo nombre. int count = 40; puesto bajo una línea que ya creó count es un error distinto. 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.

int count = forty; trata forty como un nombre. Este archivo no tiene un nombre forty. javac escribe un error. El número son los dígitos 40, no la palabra. Vuelve a poner los dígitos. int count; sin = 40, seguido de la línea de escritura, también hace que javac escriba un error. El nombre existiría como un tipo y todavía no guardaría un número. Pon = 40 en la línea que crea el nombre, como lo tiene el archivo que guardas.

Un signo menos pertenece a los dígitos

Una marca escrita contra los dígitos es parte de ese único número. La marca es el carácter - y no hace falta un espacio entre ella y el primer dígito. int count = -4; guarda un número entero. No hay un segundo número en la línea. Esta página no quita 4 de otro número. No hay un signo más ni un segundo guardado de un número para unirlo con este. La línea de escritura sigue siendo System.out.println(count);. La pantalla muestra -4. Una línea. La marca está en la pantalla, pegada al dígito. El nombre count no está en la pantalla.

Este es el segundo archivo. No es el archivo que guardas. El archivo que guardas guarda 40, sin signo menos, y su pantalla es 40. Guarda este segundo archivo como Mint.java cuando quieras ver la marca, y luego vuelve a dejar int count = 40;.

Escribe javac Mint.java. El archivo está bien, así que javac no escribe ninguna línea. Un signo menos pegado a un dígito no hace fallar a javac. Luego escribe java Mint. La pantalla muestra -4. Una línea. Sin comillas. Si la pantalla muestra 4, falta la marca en la línea de guardado. Si la pantalla muestra 40, sigues en el archivo que guardas, que es el archivo correcto al que volver, pero no es esta comprobación. Si la pantalla muestra -40, la línea de guardado tiene la marca y los dos dígitos. Eso también es un número, la marca junto con 40, y no es el segundo archivo. El segundo archivo es solo -4. Un espacio entre la marca y el dígito, int count = - 4;, sigue siendo ese mismo número. javac se queda callado, y la pantalla sigue siendo -4, con la marca pegada al dígito. El espacio del archivo no es un espacio en la pantalla, y no es un segundo número. El archivo que guardas no usa la marca. Después de ver -4, vuelve a dejar el archivo guardado: int count = 40; y un System.out.println(count);.

Un cero escrito primero es otro número

Un 0 escrito antes de los otros dígitos no es «los mismos dígitos con un 0 de más». int count = 040; es una línea que javac acepta, así que javac no escribe ninguna línea. Luego java Mint escribe 32. La pantalla no es 40, y no es 040. Java lee un número entero que empieza por 0 en grupos de ocho, no en las decenas que usas para 40. El 4 de 040 son cuatro ochos, que son 32, y el último 0 no añade nada. No tienes que rehacer ese agrupamiento en papel cada vez. El hecho útil es la pantalla: 32, no 40. Borra el 0 de delante para que la línea de guardado vuelva a ser int count = 40; antes de dejar la página. No dejes 040 en el archivo que guardas.

Un 0 solo es el número cero, y está permitido. int count = 0; guarda 0. System.out.println(count); escribe 0. javac no escribe ninguna línea. java Mint escribe 0 y termina. No espera. Una pantalla en blanco querría decir que falta la línea de escritura. El dígito 0 en la pantalla es el número que guardaste, no una línea vacía. Ese 0 solo no es lo mismo que un 0 escrito delante de otros dígitos. 0 empieza y acaba en ese único dígito. 40 empieza por 4. 040 empieza por 0 y luego tiene más dígitos, y esa es la línea cuya pantalla es 32.

Un 0 delante seguido de 8 o de 9 no cabe en ese agrupamiento. int count = 08; hace que javac escriba un error. int count = 09; hace lo mismo. Esas líneas no son una forma callada de guardar ocho o nueve. Borra el 0 de delante. Ocho como número entero es int count = 8;, y la pantalla es 8. No necesitas 08 en esta página. El archivo que guardas es 40, que empieza por 4, así que el archivo que guardas no tiene este error. El error es solo para una línea que empieza por 0 y luego un dígito que no cabe en el agrupamiento.

Las líneas y las pantallas están juntas aquí. El archivo que guardas es la primera fila. Las otras filas son comprobaciones. No son archivos extra que dejes guardados.

Lee la tabla junto a una ejecución, no en lugar de una. Para 40, javac no escribe ninguna línea y java Mint escribe 40. Para -4, javac no escribe ninguna línea y java Mint escribe -4. Para 0, javac no escribe ninguna línea y java Mint escribe 0. Para 040, javac no escribe ninguna línea y java Mint escribe 32. Después de cada comprobación, vuelve a dejar int count = 40;. La pantalla que guardas es 40, una línea, sin marca y sin 0 delante.

Ahora puedes escribir un número entero como dígitos en el archivo y ver esos dígitos en la pantalla. int count = 40; guarda 40. System.out.println(count); escribe 40 y termina la línea. Los dos dígitos son un número, no un recuento de letras y no dos líneas. int count = -4; escribe -4, y la marca es parte de ese único número. int count = 0; escribe 0. int count = 040; deja a javac callado y hace que java Mint escriba 32, así que un 0 delante no es el número que querías. Un espacio o una coma entre los dígitos hace que javac escriba un error. La página siguiente deja estos dígitos. Guarda un valor que no es un número entero y no es una línea de letras.

La pantalla es el número que guardaste

El archivo que guardas escribe 40. El nombre en la línea de escritura es count, y count no está en la pantalla. En ese archivo no hay comillas. Un println es una línea. Un signo menos, cuando usas el segundo archivo, es parte del número de esa línea. Un 0 escrito primero es otro número, y no pertenece al archivo que guardas.