Argumentos del programa en Java

Pasas palabras en la línea de comandos al iniciar un programa y las lees dentro de main. En Flag.java mantén la clase pública Flag y el parámetro String[] args. Imprime args[0] en la primera demo. En la segunda demo imprime args.length, luego args[0]. Compila con javac Flag.java. Ejecuta java Flag oak para que la primera palabra tras el nombre de clase sea oak. La primera pantalla muestra oak. Deja Generics opcional para páginas posteriores. Esta lección son palabras de línea de comandos en args, no una conversación con Scanner ni una etiqueta de Mini Project.

Lee la primera palabra tras el nombre de clase

Abre Flag.java. Mantén el nombre de clase pública Flag. Borra demos sobrantes de Mini Project Box con Scanner, impresiones sobrantes de compilación Build, líneas sobrantes de Summary Recap y tiradas Random sobrantes de Dice si enterraran la historia de argumentos. Este programa no debe esperar entrada de teclado con Scanner.
Dentro de Flag.main mantén la lista de parámetros como String[] args e imprime la primera palabra:
System.out.println(args[0]);
Desde la carpeta que contiene Flag.java ejecuta javac Flag.java. Luego java Flag oak — no java Flag.java oak. El nombre de clase es Flag. La palabra oak es el primer argumento del programa. Aterriza en args[0]. La pantalla muestra oak.

Recorre la ejecución una vez. javac escribe Flag.class. java Flag oak carga la clase y llena args con un elemento: "oak". Arranca main. args[0] es "oak". println escribe oak. Nada pregunta item:. Nada imprime mug 4. Nada imprime ok de Build.
Repite la regla de principiante mientras miras el comando: las palabras tras el nombre de clase pasan a args. El índice 0 es la primera palabra. No inventes demos de Generics en esta página. Generics opcional espera tras el núcleo. No escribas solo java Flag y luego leas args[0] — ese arreglo vacío no tiene primera palabra y la ejecución puede lanzar error.
Si aún ves mug 4 de un archivo Box sobrante, cambia a Flag.java, compila y ejecuta java Flag oak. Si javac se queja del nombre de clase, mantén public class Flag acorde con Flag.java.

Cuenta las palabras, luego imprime la primera

Un argumento demuestra args[0]. Una segunda demo muestra args.length junto con la primera palabra. Mantén la misma clase pública Flag. Imprime dos líneas:
System.out.println(args.length);
System.out.println(args[0]);
Compila otra vez con javac Flag.java. Ejecuta java Flag oak pine. La pantalla muestra 2, luego oak. La longitud es 2 porque dos palabras siguen al nombre de clase. La primera palabra sigue siendo oak. La segunda palabra pine está en args[1], pero esta demo no la imprime.
Si ejecutas java Flag oak en esta demo de dos líneas, la pantalla muestra 1, luego oak. La longitud sigue cuántas palabras escribiste tras Flag.

Compila con javac Flag.java y ejecuta java Flag oak pine otra vez. Recorre la ejecución una vez. args.length es 2. args[0] es "oak". Las impresiones escriben esas dos líneas. Nada espera Scanner. Nada une mug y 4.
Conserva las dos demos como dos formas didácticas. Primero demuestra un argumento impreso. Luego longitud más primera palabra. Ambas comparten el mismo nombre de clase y la misma idea: las palabras tras java Flag llenan args.
Si escribes java Flag.java oak, usas la forma de ejecución equivocada para este camino del curso. Mantén java Flag más las palabras. Si olvidas compilar tras un cambio, un .class viejo puede mostrar una forma de impresión antigua — compila otra vez, el mismo hábito de Compilación.

args no es Scanner ni Mini Project

Mini Project te pidió escribir respuestas mientras el programa esperaba. Los argumentos del programa piden pasar palabras al iniciar. Scanner lee de System.in después de que arranca el proceso. args ya está lleno antes de que corra main. No mezcles esos dos estilos de entrada en un solo archivo de principiante hoy.
oak es solo una palabra didáctica. No es una semilla Random ni una fila de mapa Summary. Cuando una demo Box sobrante aún espera en item:, ese archivo hace trabajo de Mini Project. Cambia a Flag y pasa oak en la línea de comandos.
Sin al menos una palabra, leer args[0] falla. Con palabras presentes, los índices empiezan en 0. args.length dice cuántas palabras pasaste. Mantén esos tres hechos juntos.

Punto de control del núcleo

Ya construiste clases con main, compilaste con javac, ejecutaste con java, guardaste valores, decidiste con if, recorriste bucles, llamaste métodos, usaste objetos y listas, atrapaste errores, leíste archivos y moldeaste herencia. Mini Project unió dos respuestas escritas en mug 4. Los argumentos del programa muestran otra forma de alimentar un programa: palabras en la línea de arranque.
Esta página termina el camino núcleo de Java en este curso. Páginas opcionales como Generics vienen después, si quieres. No son obligatorias para terminar el núcleo. No trates esta lección de argumentos como lugar para inventar esos temas opcionales.
Mantén una Flag pública. Mantén String[] args en main. Mantén el comando de ejecución como java Flag más palabras. Deja demos Scanner de Mini Project fuera de esta página cuando practiques argumentos.

Comprobaciones de carpeta antes de cerrar el núcleo

Lista la carpeta tras compilar bien. Debes ver Flag.java y Flag.class juntos. Edita el fuente, guarda, ejecuta javac Flag.java, luego java Flag oak o java Flag oak pine. Falta .class significa compilar primero. Carpeta equivocada significa que el launcher no encuentra Flag.
Si la pantalla no muestra nada, confirma que main aún imprime. Si la ejecución lanza porque args está vacío, añade una palabra tras el nombre de clase. Si dos clases públicas comparten un archivo, deja solo Flag pública.
No pegues prompts Scanner de Box en Flag para «enriquecer» la página. No reconstruyas aquí las impresiones ok de Build. El trabajo didáctico son solo palabras de línea de comandos.

Antes de Generics opcional

Puedes mantener clase pública Flag, leer String[] args en main, imprimir args[0] para java Flag oak, imprimir args.length luego args[0] para java Flag oak pine, compilar con javac Flag.java y ejecutar sin la terminación .java en el nombre de clase. El núcleo termina en esta página. Generics opcional espera si continúas después.
Conserva las demos Flag como un par de argumentos claro. Deja archivos Mini Project Box fuera de esta página al practicar args. Deja demos de compilación Build fuera de esta página al practicar args. Deja trabajo de Generics fuera de esta página hasta una lección opcional. Esos hábitos son el checkpoint antes de salir del núcleo. Cuando la ejecución de una palabra muestra oak o la de dos palabras muestra 2 luego oak, los argumentos del programa cumplieron su trabajo en esta lección y el camino núcleo de Java está completo.
Un último pase por la carpeta: una Flag pública, String[] args en main, sin espera Scanner, sin Random, sin LocalDate, compilar y ejecutar con palabras tras el nombre de clase. Ejecuta javac Flag.java y java Flag oak una vez más. Si la pantalla sigue mostrando oak, la forma de argumentos del programa es sólida y el curso puede marcar el núcleo completo mientras las páginas opcionales quedan disponibles después. Prefiere un hábito de argumentos claro por lectura para que cada paso enseñe el mismo mapa.