JAR en Java

Empaqueta archivos de clase compilados en un jar para enviarlos y ejecutarlos como un solo archivo. En Pack.java mantén la clase pública Pack, imprime packed desde main, compila con javac Pack.java, luego crea Pack.jar con jar --create --file Pack.jar Pack.class. Ejecuta con java -cp Pack.jar Pack para que la pantalla muestre packed. La segunda demo imprime shipped y usa un jar que nombra Main-Class para que java -jar Pack.jar funcione. Esta lección es empaquetado jar, no una comprobación @Test de JUnit ni una impresión de accesorios de Records.

Un jar, ejecutar con -cp

Abre Pack.java. Mantén el nombre de clase pública Pack. Borra los asserts JUnit sobrantes de SumCheck, las demos Records sobrantes de Card, las tuberías Streams sobrantes de Pipe y los recorridos lambda sobrantes de Cue si entierran la historia del jar. El archivo didáctico es un programa pequeño con main que empaquetas, no una clase de prueba con assertEquals.
Dentro de Pack.main imprime una palabra:
System.out.println("packed");
Compila primero:
javac Pack.java
Cuando las llaves coinciden, javac queda en silencio y escribe Pack.class. Luego crea el jar desde el archivo de clase:
jar --create --file Pack.jar Pack.class
Ejecuta la clase desde el jar en el classpath:
java -cp Pack.jar Pack
La pantalla muestra packed. No lanzas java Pack desde clases sueltas en esta forma didáctica. Pides a la JVM cargar Pack desde Pack.jar.

Recorre el camino una vez. javac Pack.java construye Pack.class. jar --create --file Pack.jar Pack.class mete esa clase en Pack.jar. java -cp Pack.jar Pack inicia Pack.main. println escribe packed. No corre @Test. No corre t.name(). No corre stream().map.
Di la regla de principiante mientras miras la carpeta: compila el fuente, crea el jar desde el .class, ejecuta con -cp y el nombre de clase pública. No inventes comprobaciones JUnit dentro de Pack.java en esta página. No trates jar como un segundo compilador — javac sigue construyendo la clase; jar solo empaqueta.
Si aún ves un informe JUnit verde de un archivo SumCheck sobrante, cambia a Pack y conserva la impresión packed. Si jar dice que no encuentra Pack.class, compila otra vez antes de crear el archivo.

jar con Main-Class, ejecutar con -jar

Mantén la misma clase pública Pack. Cambia la impresión para que la segunda forma didáctica sea fácil de nombrar:
System.out.println("shipped");
Compila otra vez:
javac Pack.java
Crea un jar que registre la clase de entrada:
jar --create --file Pack.jar --main-class Pack Pack.class
Ejecuta con el lanzador del jar:
java -jar Pack.jar
La pantalla muestra shipped. --main-class Pack le dice al jar qué clase pública tiene main. java -jar lee esa entrada y la inicia. Mantén una impresión clara por forma didáctica para que la palabra de pantalla sea fácil de nombrar.

Recorre el camino una vez. javac Pack.java renueva Pack.class. jar --create --file Pack.jar --main-class Pack Pack.class empaqueta la clase y guarda el nombre de entrada. java -jar Pack.jar inicia Pack.main. La pantalla muestra shipped. Mantén las dos demos como dos formas didácticas. Primero demuestra una ejecución -cp que quiere packed. Luego demuestra una ejecución -jar que quiere shipped. Ambas formas comparten clase pública Pack y el hábito jar --create --file.
Si ejecutas java -jar Pack.jar en un jar que nunca recibió --main-class, el lanzador falla porque no hay clase de entrada guardada. Ese jar fallido no es el segundo archivo didáctico. El segundo archivo didáctico incluye --main-class Pack.

Hábitos JAR

Crear, ejecución classpath, Main-Class y ejecución -jar siguen siendo pasos de principiante separados.

JAR no es JUnit ni Records

JUnit marcaba comprobaciones con @Test y comparaba valores esperados. Records guardaban componentes compactos que imprimías con accesores. JAR empaqueta archivos de clase para enviar y ejecutar. No mezcles esos tres trabajos en un archivo de principiante hoy.
packed aquí es la palabra de pantalla de la primera demo desde Pack.main dentro de una ejecución jar con -cp. No es assertEquals(5, ...) ni t.name() de un record Tag. Cuando un archivo SumCheck sobrante aún habla de esperado 5, déjalo como historia y conserva la línea de impresión de Pack.
Sin javac no hay Pack.class fresca para empaquetar. Sin jar --create no hay Pack.jar. Sin -cp o una ruta -jar con Main-Class no has mostrado las formas de ejecución de esta lección. Mantén anotaciones JUnit fuera de esta página. Mantén cabeceras record fuera de esta página.

Comprobaciones de carpeta en la última página opcional

Lista la carpeta tras un create exitoso. Debes ver Pack.java, Pack.class y Pack.jar juntos. Edita el fuente, guarda, ejecuta javac Pack.java, recrea el jar con el mismo hábito create, luego ejecuta otra vez. Un jar viejo puede ocultar una impresión cambiada si saltas create tras editar.
Si jar se queja de un archivo de clase ausente, compila primero. Si java -cp Pack.jar Pack no imprime nada, confirma que main aún llama println. Si java -jar Pack.jar dice no main manifest attribute, recrea con --main-class Pack.
No pegues @Test de SumCheck en Pack. No pegues record Tag de Card como reemplazo del empaquetado. El trabajo opcional JAR es un archivo de archivos de clase que ejecutas con -cp o -jar.

Fin del camino opcional

Puedes mantener clase pública Pack, imprimir packed, compilar con javac Pack.java, crear Pack.jar con jar --create --file Pack.jar Pack.class, ejecutar java -cp Pack.jar Pack, luego imprimir shipped, recrear con --main-class Pack y ejecutar java -jar Pack.jar. La tabla separa create, ejecución classpath, Main-Class y ejecución jar. Esta es la última página opcional de Java en el mapa del curso.
Conserva las demos Pack para un par de empaquetado claro. Mantén archivos JUnit de SumCheck fuera de esta página al practicar jar. Mantén archivos Records de Card fuera de esta página al practicar jar. Mantén inventar temas opcionales nuevos fuera de esta página — el mapa termina aquí. Esos hábitos son el punto de control del camino opcional. Cuando la primera ejecución muestra packed o la segunda shipped, JAR cumplió su trabajo en esta lección.
Un último repaso de la carpeta: un Pack público, .class coincidente, Pack.jar presente, comando create recordado, ejecución -cp o -jar acorde a la demo abierta, sin espera de Scanner, sin assertion requerida. Compila, recrea el jar y ejecuta una vez más en la demo abierta. Si la pantalla sigue mostrando packed o shipped, la forma JAR es sólida y el camino opcional Java está completo. Prefiere un hábito de empaquetado claro por lectura para que cada paso enseñe el mismo mapa.