JAR em Java

Empacote arquivos de classe compilados em um jar para enviar e executar tudo em um único arquivo. Em Pack.java, mantenha a classe pública Pack, imprima packed a partir de main, compile com javac Pack.java e crie Pack.jar com jar --create --file Pack.jar Pack.class. Execute com java -cp Pack.jar Pack para a tela mostrar packed. Uma segunda demo imprime shipped e usa um jar que declara Main-Class para java -jar Pack.jar funcionar. Esta lição é empacotamento jar, não verificação JUnit @Test e não impressão de acessor Records.

Um jar, execução com -cp

Abra Pack.java. Mantenha o nome da classe pública Pack. Apague assertEquals JUnit sobrando de SumCheck, demos Records Card sobrando, pipelines Streams Pipe sobrando e caminhadas lambda Cue sobrando se esconderem a história do jar. O arquivo de ensino é um programa main pequeno que você empacota, não uma classe de teste assertEquals.
Dentro de Pack.main, imprima uma palavra:
System.out.println("packed");
Compile primeiro:
javac Pack.java
Quando as chaves batem, javac fica quieto e grava Pack.class. Depois crie o jar a partir do arquivo de classe:
jar --create --file Pack.jar Pack.class
Execute a classe do jar no classpath:
java -cp Pack.jar Pack
A tela mostra packed. Você não lança java Pack a partir de classes soltas nesta forma de ensino. Você pede à JVM carregar Pack de Pack.jar.

Percorra o caminho uma vez. javac Pack.java gera Pack.class. jar --create --file Pack.jar Pack.class empacota essa classe em Pack.jar. java -cp Pack.jar Pack inicia Pack.main. println escreve packed. Nenhum @Test roda. Nenhum t.name() roda. Nenhum stream().map roda.
Diga a regra de iniciante olhando a pasta: compile a fonte, crie o jar a partir do arquivo .class, execute com -cp e o nome da classe pública. Não invente verificações JUnit dentro de Pack.java nesta página. Não trate jar como segundo compilador — javac ainda constrói a classe; jar só empacota.
Se ainda vir relatório JUnit verde de arquivo SumCheck sobrando, mude para Pack e mantenha a impressão packed. Se jar disser que não acha Pack.class, compile de novo antes de criar o arquivo.

Jar Main-Class, execução com -jar

Mantenha a mesma classe pública Pack. Mude a impressão para a segunda forma de ensino ser fácil de nomear:
System.out.println("shipped");
Compile de novo:
javac Pack.java
Crie um jar que registra a classe de entrada:
jar --create --file Pack.jar --main-class Pack Pack.class
Execute com o lançador jar:
java -jar Pack.jar
A tela mostra shipped. --main-class Pack diz ao jar qual classe pública tem main. java -jar lê essa entrada e inicia. Mantenha uma impressão clara por forma de ensino para a palavra na tela continuar fácil de nomear.

Percorra o caminho uma vez. javac Pack.java atualiza Pack.class. jar --create --file Pack.jar --main-class Pack Pack.class empacota a classe e guarda o nome de entrada. java -jar Pack.jar inicia Pack.main. A tela mostra shipped. Mantenha as duas demos como duas formas de ensino. Primeiro prove uma execução -cp que quer packed. Depois prove uma execução -jar que quer shipped. As duas formas compartilham classe pública Pack e o hábito jar --create --file.
Se você rodar java -jar Pack.jar em um jar que nunca recebeu --main-class, o lançador falha porque nenhuma classe de entrada foi armazenada. Esse jar falho não é o segundo arquivo de ensino. O segundo arquivo de ensino inclui --main-class Pack.

Hábitos JAR

Criar, execução classpath, Main-Class e execução -jar permanecem gestos de iniciante separados.

JAR não é JUnit nem Records

JUnit marcava verificações com @Test e comparava valores esperados. Records guardavam componentes compactos impressos com acessores. JAR empacota arquivos de classe para envio e execução. Não misture esses três papéis em um arquivo iniciante hoje.
packed aqui é a palavra de tela da primeira demo de Pack.main numa execução jar com -cp. Não é assertEquals(5, ...) nem t.name() de um record Tag. Quando um arquivo SumCheck sobrando ainda fala de 5 esperado, deixe isso como histórico e mantenha a linha de impressão de Pack.
Sem javac, não há Pack.class fresco para empacotar. Sem jar --create, não há Pack.jar. Sem o caminho -cp ou -jar com Main-Class, você não mostrou as formas de execução desta lição. Mantenha anotações JUnit fora desta página. Mantenha cabeçalhos record fora desta página.

Verificações de pasta na última página opcional

Liste a pasta após uma criação bem-sucedida. Você deve ver Pack.java, Pack.class e Pack.jar juntos. Edite a fonte, salve, rode javac Pack.java, recrie o jar com o mesmo hábito de criação e execute de novo. Um jar velho pode esconder uma impressão alterada se você pular create depois de editar.
Se jar reclamar de arquivo de classe ausente, compile primeiro. Se java -cp Pack.jar Pack não imprimir nada, confirme que main ainda chama println. Se java -jar Pack.jar disser que não há atributo main manifest, recrie com --main-class Pack.
Não cole @Test de SumCheck em Pack. Não cole record Tag de Card no lugar do empacotamento. O trabalho JAR opcional é um arquivo de arquivos de classe que você executa com -cp ou -jar.

Fim do caminho opcional

Você pode manter a classe pública Pack, imprimir packed, compilar com javac Pack.java, criar Pack.jar com jar --create --file Pack.jar Pack.class, executar java -cp Pack.jar Pack, depois imprimir shipped, recriar com --main-class Pack e executar java -jar Pack.jar. A tabela separa criar, execução classpath, Main-Class e execução jar. Esta é a última página opcional Java no mapa do curso.
Mantenha as demos Pack para um par claro de empacotamento. Mantenha arquivos JUnit SumCheck fora desta página ao praticar jar. Mantenha arquivos Records Card fora desta página ao praticar jar. Mantenha inventar novos tópicos opcionais fora desta página — o mapa termina aqui. Esses hábitos são o checkpoint do caminho opcional. Quando a primeira execução mostra packed ou a segunda mostra shipped, o JAR cumpriu seu papel nesta lição.
Uma última passagem pela pasta: um Pack público, .class correspondente, Pack.jar presente, comando create lembrado, execução -cp ou -jar alinhada à demo aberta, sem espera Scanner, sem assertion obrigatória. Compile, recrie o jar e execute mais uma vez na demo aberta. Se a tela ainda mostra packed ou shipped, a forma JAR está sólida e o caminho opcional Java está completo. Prefira um hábito claro de empacotamento por leitura para cada passagem ensinar o mesmo mapa.