La palabra null sin comillas en Java

String plant = null; no guarda ninguna letra, y System.out.println(plant) escribe null. La pantalla es una línea. No hay comillas alrededor de null, y no hay ningún dígito en esa línea.

El nombre no guarda ninguna letra

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 todavía está, incluido (int), 40.0, 40.9 y 40. Borra double weight si todavía está. Borra boolean ripe si todavía está, incluido true y false. Borra plant.length y borra charAt. 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 count, no tiene weight, no tiene ripe y no tiene paréntesis. Un import sin uso no hace fallar a javac por sí solo, y tampoco escribe null. La palabra la escribe solo la línea de escritura que usa el nombre.

Dentro de main, la línea de guardado es String plant = null;. String es la palabra del tipo. Dice que este nombre puede guardar letras, o puede no guardar ninguna letra. plant es el nombre, y empieza con una p minúscula. El signo = guarda. La palabra es null, cada letra minúscula: n, u, l, l. No hay una N mayúscula. No hay comillas alrededor de null. No hay ningún dígito. El punto y coma termina la línea. Esta línea no guarda ninguna letra. No escribe la pantalla. Guardar no es escribir. La pantalla se queda en blanco durante esta línea. null no es una forma corta de escribir el número 0. null no es la palabra leaf con las letras ausentes solo de la pantalla. No hay nada guardado. Las letras leaf no esperan en algún sitio dentro de este nombre.

En esta página, este tipo guarda o letras entre comillas, como leaf, o la palabra null sin comillas. No inventas una tercera palabra. String plant = none; trata none como un nombre. Este archivo no tiene un nombre none. javac escribe un error. String plant = empty; hace lo mismo. La palabra que puedes escribir, con esta palabra del tipo y sin comillas, es null. El archivo que guardas usa null.

La línea de escritura es el nombre solo: System.out.println(plant);. Sin comillas, y sin punto. Java lee el nombre plant, escribe lo que ese nombre guarda y termina la línea. Para el archivo que guardas, el nombre no guarda ninguna letra, así que la línea de escritura escribe la palabra null. 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. La palabra null 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 del tipo, String. Un nombre, plant. Una palabra, null, todo en minúsculas, sin comillas, sin dígito. Una línea de escritura, y esa línea usa el nombre solo. No hay length ni charAt.

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 todavía no es una línea de guardado. La línea de guardado es la posterior, String plant = null;. No escribe nada. System.out.println(plant); escribe null y termina la línea. Una línea en la pantalla. Sin comillas. Sin segunda línea. No hay una línea int en el archivo que guardas.

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 null después de String 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 la marca que el shell muestra antes del comando. El programa escribe null. 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 String plant = null; y la única línea de escritura. El programa termina después de la línea de escritura.

La pantalla muestra null. Una línea. 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, así que la palabra guardada no se escribe. Si la pantalla muestra leaf, la línea de guardado todavía dice "leaf". Borra esas comillas y las letras, y escribe null sin comillas. Si la pantalla muestra 40, o 40.0, o 4, el archivo de los paréntesis o el archivo de los números sigue en su sitio. Borra la línea int y los paréntesis. Si la pantalla muestra true o false, ripe sigue en el archivo. Si la pantalla muestra mint, sigues en un archivo más viejo. Si la pantalla muestra una línea en blanco y no la palabra null, la línea de guardado tiene comillas y nada entre ellas: String plant = "";. Ese no es el archivo que guardas. El archivo que guardas tiene la palabra null y no tiene comillas. No vuelves a instalar Java porque la pantalla muestre la línea equivocada.

Una pantalla que muestra null no prueba el archivo por sí sola. String plant = "null"; con comillas alrededor de esas cuatro letras también escribe null, porque las comillas guardan n, u, l, l. La pantalla puede verse igual. El archivo no. El archivo que guardas tiene String, y tiene null sin comillas. Cuando juzgas esta página, busca la palabra del tipo y busca la ausencia de comillas. No juzgues el archivo solo por la pantalla.

Las comillas guardan las letras null

Las comillas alrededor de la palabra son letras, no el nombre vacío. String plant = "null"; guarda cuatro letras. javac no escribe ninguna línea. java Mint escribe null. Esa ejecución está permitida, y no es el archivo que guardas. El archivo que guardas no tiene comillas, así que el nombre no guarda ninguna letra. Cuando reparas el archivo que guardas, borra las comillas para que la línea vuelva a ser String plant = null;. No borres la palabra null con ellas.

Lee la tabla junto a una ejecución, no en lugar de una. Para String plant = null;, javac no escribe ninguna línea y java Mint escribe null. Para String plant = "null";, javac no escribe ninguna línea y java Mint escribe null, y el archivo todavía tiene comillas. Para String plant = "leaf";, javac no escribe ninguna línea y java Mint escribe leaf. Para int count = null;, javac escribe un error, así que no escribes java Mint. Después de cada comprobación, vuelve a poner String plant = null;, sin comillas. La pantalla que guardas es null, una línea.

El nombre tiene que existir antes de que una línea lo use. Si System.out.println(plant); está escrito encima de String plant = null;, javac escribe un error. La línea de escritura nombra plant antes de que plant exista. Mueve la línea de guardado por encima de la línea de escritura. No escribas String una segunda vez para el mismo nombre. String plant = "leaf"; debajo de una línea que ya creó plant es un error distinto. javac escribe un error y no se queda callado. El nombre se crea una vez. Una línea posterior puede poner letras sin escribir String otra vez, una vez que plant ya existe: plant = "leaf";. Esa línea solo sustituye lo que el nombre guarda. Está permitida. No es el archivo que guardas. El archivo que guardas tiene una línea de guardado, y esa línea dice null.

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

Una letra mayúscula no es la palabra. String plant = Null; trata Null como un nombre, porque la primera letra es una N mayúscula. Este archivo no tiene un nombre Null. javac escribe un error. No se queda callado. La pantalla no muestra Null, porque no ejecutas java Mint mientras javac escribe un error. La palabra en el archivo que guardas es null, todo en minúsculas. Vuelve a poner las letras minúsculas.

null no es un número entero

Un número entero es el tipo de la página de los números. int count = null; pide a ese tipo que guarde ninguna letra. null no cabe. javac escribe un error. No convierte null en 0. No escribe null. boolean ripe = null; pide al tipo de dos palabras que guarde null. Ese tipo guarda solo true o false. javac escribe un error. No convierte null en false. No hay pantalla que leer, porque no escribes java Mint mientras javac escribe un error. No necesitas el texto exacto de estos errores. Cuando reparas el archivo que guardas, borra la línea int y la línea boolean, y escribe otra vez String plant = null;.

Una pregunta después del nombre es otro fallo, y no es un fallo de javac. El segundo archivo guarda null y luego pregunta cuántas letras guarda ese nombre.

Este es el segundo archivo. No es el archivo que guardas. Escribe javac Mint.java. El archivo está bien en lo que javac puede ver, así que javac no escribe ninguna línea. La palabra null no hace fallar a javac, y length tampoco. Luego escribe java Mint. El programa no escribe un número. No escribe 4, no escribe 0, y no escribe null. java Mint escribe un error. No necesitas el texto exacto de ese error. El nombre no guarda ninguna letra, así que no hay un recuento de letras que escribir. Si la pantalla muestra 4, plant todavía guarda leaf, y length cuenta esas cuatro letras. Borra "leaf" y deja null, o, para el archivo que guardas, borra length por completo. La línea de escritura en el archivo que guardas es System.out.println(plant); sin punto y sin length. Después de ver el error, vuelve a poner el archivo que guardas.

Ahora puedes no guardar ninguna letra en un nombre y escribir la palabra null sin comillas y sin dígito. String plant = null; no guarda ninguna letra. System.out.println(plant); escribe null y termina la línea. Las comillas alrededor de null guardan cuatro letras, y la pantalla puede verse igual, así que juzgas el archivo. int count = null; y boolean ripe = null; hacen cada uno que javac escriba un error. Null con una N mayúscula es un nombre que este archivo no tiene. plant.length() después de null deja a javac callado y hace que java Mint escriba un error. La página siguiente deja este nombre vacío. Mira más de un valor guardado bajo un solo nombre.

La pantalla es la palabra null

El archivo que guardas escribe null. El nombre en la línea de escritura es plant, y plant no está en la pantalla. En ese archivo no hay comillas. Un println es una línea. La misma pantalla a través de comillas son cuatro letras, no el archivo que guardas. Un dígito no pertenece al archivo que guardas. Una pregunta después del nombre no es el archivo que guardas.