Nombres en Java
Quieres que una línea de escritura muestre la palabra que guarda un nombre. En la página anterior la palabra estaba entre comillas en la propia línea de escritura, así que cambiar la pantalla significaba editar esa línea. En esta página le das a la palabra un nombre, plant, y la línea de escritura usa ese nombre. Las comillas pasan a la línea que guarda la palabra. System.out.println(plant) no tiene comillas, y la pantalla sigue mostrando 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 println escribe las letras y termina la línea. El trabajo nuevo es el nombre que guarda esas letras.
Un nombre guarda las letras
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 la línea public class Mint. Dentro de main, encima de la línea de escritura, añade una línea que crea un nombre y guarda una palabra en él: String plant = "leaf";. String dice que este nombre guarda letras. plant es el nombre, y empieza con una p minúscula. El signo = guarda la palabra. Las comillas contienen leaf, todo en minúsculas, la misma palabra que la página anterior puso en la línea de escritura. El punto y coma termina esta línea. Luego cambia la línea de escritura para que ya no tenga comillas. Queda System.out.println(plant);. El nombre plant va solo. No hay comilla antes de la p ni después de la t. Guarda el archivo.
El archivo que conservas
Guarda esto como Mint.java. Este es el archivo que conserva esta página. El nombre plant guarda la palabra leaf. La línea de escritura usa ese nombre y no contiene comillas.
public class Mint {
public static void main(String[] args) {
String plant = "leaf";
System.out.println(plant);
}
}
Lee desde arriba y decide qué puede mostrar la pantalla. public class Mint nombra el archivo. No escribe la pantalla. 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 de la línea siguiente. La línea main es el inicio. La línea siguiente es la que crea el nombre. String plant = "leaf"; guarda las letras l, e, a y f en el nombre plant. Esta línea no escribe esas letras en la pantalla. Guardar no es escribir. La pantalla sigue vacía hasta el final de esta línea. La línea de después, System.out.println(plant);, es la línea de escritura. Java lee el nombre plant, escribe las letras que ese nombre guarda y termina la línea. La pantalla muestra leaf. Una línea. Sin comillas. Las letras del propio nombre, plant, no están en la pantalla. System no está en la pantalla. El punto y coma no está en la pantalla.
Ejecútalo igual que antes. En la carpeta que contiene este Mint.java, escribe javac Mint.java. Cuando el archivo está bien, este comando no escribe ninguna línea. Un nombre en el archivo no hace que javac escriba una línea, ni hace que falle. Luego escribe java Mint. No escribas .java después de java. La pantalla muestra leaf. Si la pantalla muestra plant, la línea de escritura tiene comillas alrededor de plant. El archivo que conservas no las tiene. Si la pantalla sigue mostrando mint, la palabra guardada sigue siendo mint, o la línea de escritura sigue siendo System.out.println("mint");. Mira las letras entre las comillas de la línea String, y mira si la línea de escritura usa el nombre solo. No vuelvas a instalar Java porque la pantalla muestre la palabra equivocada.
Cambia la palabra y deja la línea de escritura
La utilidad del nombre es que la línea de escritura puede quedarse y la palabra guardada puede cambiar. Debajo de la primera línea de escritura, guarda una palabra nueva en el mismo nombre y luego escribe el nombre otra vez. La nueva línea de guardado es plant = "stem";. No empieza con String. plant ya existe, así que esta línea solo sustituye las letras que el nombre guarda. stem ocupa el lugar de leaf, todo en minúsculas. La siguiente línea de escritura es otra vez System.out.println(plant);. Tiene la misma forma que la primera línea de escritura. La pantalla tiene ahora dos líneas, porque cada println termina su línea. La primera línea es leaf, de las letras que el nombre guardaba en ese momento. La segunda línea es stem, de las letras que el nombre guarda después de plant = "stem";.
Este es el segundo archivo. No es el archivo que conservas. El archivo que conservas tiene una línea de guardado y una línea de escritura, y su pantalla es leaf. Guarda este segundo archivo como Mint.java cuando quieras ver el cambio de la palabra, y luego vuelve a poner la única línea de guardado y la única línea de escritura.
public class Mint {
public static void main(String[] args) {
String plant = "leaf";
System.out.println(plant);
plant = "stem";
System.out.println(plant);
}
}
En la misma carpeta 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. La pantalla muestra leaf, y la línea siguiente de la pantalla es stem. Dos líneas. leaf está arriba porque el primer System.out.println(plant); se ejecuta mientras plant todavía guarda leaf. stem está debajo porque el segundo System.out.println(plant); se ejecuta después de plant = "stem";. El nombre plant no está en ninguna de las dos líneas de la pantalla. Si las dos líneas de la pantalla dicen leaf, falta la segunda línea de guardado o sigue diciendo "leaf". Si las dos dicen stem, la primera línea de guardado ya dice "stem", o la primera línea de escritura está debajo del cambio. La pantalla sigue el orden de las líneas del archivo. Cuando una línea posterior guarda una palabra nueva, la palabra vieja no se queda, y la pantalla no salta a stem antes de que se ejecute esa línea de guardado.
No escribas String una segunda vez para el mismo nombre. String plant = "stem";, 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. La reparación es borrar el segundo String y dejar plant = "stem";. El nombre se crea una vez. Las líneas posteriores solo cambian las letras que guarda. En el archivo que conservas no hay segunda línea de guardado. Después de ver leaf y luego stem, vuelve a ese archivo: un String plant = "leaf"; y un System.out.println(plant);.
Las comillas alrededor del nombre escriben el nombre
La línea de escritura del archivo que conservas es System.out.println(plant); sin comillas. Si pones comillas alrededor del nombre, la línea queda System.out.println("plant");. Esas comillas hacen lo mismo que las comillas de la página anterior. Marcan letras para la pantalla. Las letras de en medio son p, l, a, n y t. Java no busca el nombre, porque una palabra entre comillas no es un nombre. El nombre plant puede seguir guardando leaf en la línea de arriba, y la pantalla muestra plant de todos modos. La palabra guardada, leaf, no se escribe, porque la línea de escritura nunca usó el nombre. Usó una palabra entre comillas que se escribe igual que el nombre.
Este es el tercer archivo. No es el archivo que conservas. Guárdalo solo hasta que veas la única línea plant, y luego quita las comillas de la línea de escritura.
public class Mint {
public static void main(String[] args) {
String plant = "leaf";
System.out.println("plant");
}
}
Escribe javac Mint.java. El archivo está bien, así que javac no escribe ninguna línea. Las comillas alrededor de plant están permitidas. No hacen que javac falle. Tampoco hacen que la pantalla muestre la palabra guardada. Luego escribe java Mint. La pantalla muestra plant. Una línea. Sin comillas. No es leaf. No es stem. Si querías leaf, la línea de escritura tiene que ser el nombre solo, System.out.println(plant);. Las comillas van en la línea de guardado, alrededor de leaf, no en la línea de escritura alrededor del nombre. Un espacio dentro de esas comillas de guardado también se guarda. String plant = "leaf "; con un espacio después de la f hace que System.out.println(plant); escriba leaf con un espacio después. El archivo que conservas no tiene ese espacio. La pantalla del archivo que conservas es leaf, cuatro letras, y luego termina la línea.
El nombre tiene que existir primero
Java lee el archivo desde arriba. La línea que crea el nombre tiene que estar encima de la línea que usa el nombre. Si pones System.out.println(plant); primero y luego escribes String plant = "leaf";, la línea de escritura usa el nombre plant antes de que plant exista. javac escribe un error. No se queda en silencio. No hay pantalla que leer, porque no escribes java Mint mientras javac escribe un error. La reparación es volver a poner la línea String encima de la línea de escritura. El orden del archivo es el orden en el que Java lee. Un nombre no se usa en una línea anterior a la línea que lo crea.
Este cuarto 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 String arriba.
public class Mint {
public static void main(String[] args) {
System.out.println(plant);
String plant = "leaf";
}
}
Escribe javac Mint.java. javac escribe un error. No escribas java Mint. No necesitas las palabras exactas del error. El dato útil es el mismo que en la página anterior cuando faltaban las comillas: javac escribió una línea, así que el archivo no está bien. Pon String plant = "leaf"; encima de System.out.println(plant);. Guarda. Escribe javac Mint.java otra vez. Ahora javac no escribe ninguna línea. Luego java Mint muestra la palabra leaf. El nombre leaf, sin una línea String leaf en ningún sitio, sigue siendo un error, y es un error distinto de este. System.out.println(leaf); pide un nombre que se llame leaf. Este archivo no crea ese nombre. El nombre que crea se llama plant, y la palabra que guarda ahí es leaf. La palabra y el nombre no son las mismas letras. Volver a poner comillas alrededor de leaf en la línea de escritura, System.out.println("leaf");, también dejaría a javac en silencio, pero te devolvería a la página anterior. Esta página deja el nombre solo en la línea de escritura y deja las comillas en la línea de guardado.
Ahora puedes guardar una palabra en un nombre y escribir esa palabra sin poner la propia palabra en la línea de escritura. String plant = "leaf"; guarda leaf. System.out.println(plant); escribe leaf y termina la línea. Un plant = "stem"; posterior cambia la palabra guardada, y un println posterior del mismo nombre escribe stem. Las comillas alrededor del nombre escriben en su lugar las letras del nombre. La línea que crea el nombre tiene que estar encima del primer uso del nombre. La página siguiente lee una palabra que tú escribes mientras el programa se ejecuta, y guarda esa palabra en un nombre, para que la pantalla pueda mostrar letras que no estaban entre comillas en el archivo.
La pantalla es la palabra que guarda el nombre
El archivo que conservas escribe leaf. El nombre en la línea de escritura es plant, y plant no está en la pantalla. Las comillas están en la línea de guardado, alrededor de leaf. Un println es una línea. Cambiar la palabra guardada entre dos líneas println cambia solo la segunda línea de la pantalla.
🧠 Pon a Prueba tu Conocimiento
Pon a Prueba tu Conocimiento
Ponte a prueba con este cuestionario interactivo y descubre qué tan bien entiendes el tema
📝 Instrucciones
- Lee cada pregunta cuidadosamente
- Selecciona la mejor respuesta para cada pregunta
- Puedes repetir el quiz tantas veces como quieras
- Tu progreso se mostrará en la parte superior