JAR en Java

Emballez les fichiers de classes compilées dans un jar pour les expédier et les lancer en un seul fichier. Dans Pack.java, gardez la classe publique Pack, affichez packed depuis main, compilez avec javac Pack.java, puis créez Pack.jar avec jar --create --file Pack.jar Pack.class. Lancez avec java -cp Pack.jar Pack pour que l'écran montre packed. Une deuxième démo affiche shipped et utilise un jar qui nomme Main-Class pour que java -jar Pack.jar fonctionne. Cette leçon est l'empaquetage jar, pas un contrôle JUnit @Test et pas un affichage d'accesseur Records.

Un jar, lancement avec -cp

Ouvrez Pack.java. Gardez le nom de classe publique Pack. Supprimez les assertEquals JUnit restants de SumCheck, les démos Records Card restantes, les pipelines Streams Pipe restants et les parcours lambda Cue restants s'ils noient l'histoire du jar. Le fichier d'enseignement est un petit programme main à empaqueter, pas une classe de test assertEquals.
Dans Pack.main, affichez un mot :
System.out.println("packed");
Compilez d'abord :
javac Pack.java
Quand les accolades correspondent, javac reste silencieux et écrit Pack.class. Créez ensuite le jar à partir du fichier de classe :
jar --create --file Pack.jar Pack.class
Lancez la classe depuis le jar sur le classpath :
java -cp Pack.jar Pack
L'écran affiche packed. Vous ne lancez pas java Pack depuis des classes éparses pour cette forme d'enseignement. Vous demandez à la JVM de charger Pack depuis Pack.jar.

Parcourez le chemin une fois. javac Pack.java produit Pack.class. jar --create --file Pack.jar Pack.class emballe cette classe dans Pack.jar. java -cp Pack.jar Pack démarre Pack.main. println écrit packed. Aucun @Test ne s'exécute. Aucun t.name() ne s'exécute. Aucun stream().map ne s'exécute.
Énoncez la règle débutant en regardant le dossier : compilez la source, créez le jar depuis le fichier .class, lancez avec -cp et le nom de la classe publique. N'inventez pas de contrôles JUnit dans Pack.java sur cette page. Ne traitez pas jar comme un second compilateur — javac construit toujours la classe ; jar ne fait qu'emballer.
Si vous voyez encore un rapport JUnit vert issu d'un fichier SumCheck restant, passez à Pack et gardez l'affichage packed. Si jar dit qu'il ne trouve pas Pack.class, recompilez avant de créer l'archive.

Jar Main-Class, lancement avec -jar

Gardez la même classe publique Pack. Changez l'affichage pour que la deuxième forme d'enseignement soit facile à nommer :
System.out.println("shipped");
Recompilez :
javac Pack.java
Créez un jar qui enregistre la classe d'entrée :
jar --create --file Pack.jar --main-class Pack Pack.class
Lancez avec le lanceur jar :
java -jar Pack.jar
L'écran affiche shipped. --main-class Pack indique au jar quelle classe publique contient main. java -jar lit cette entrée et la démarre. Gardez un affichage clair par forme d'enseignement pour que le mot à l'écran reste facile à nommer.

Parcourez le chemin une fois. javac Pack.java rafraîchit Pack.class. jar --create --file Pack.jar --main-class Pack Pack.class emballe la classe et stocke le nom d'entrée. java -jar Pack.jar démarre Pack.main. L'écran affiche shipped. Gardez les deux démos comme deux formes d'enseignement. Prouvez d'abord un lancement -cp qui veut packed. Prouvez ensuite un lancement -jar qui veut shipped. Les deux formes partagent la classe publique Pack et l'habitude jar --create --file.
Si vous lancez java -jar Pack.jar sur un jar qui n'a jamais reçu --main-class, le lanceur échoue car aucune classe d'entrée n'est stockée. Ce jar raté n'est pas le deuxième fichier d'enseignement. Le deuxième fichier d'enseignement inclut --main-class Pack.

Habitudes JAR

Création, lancement classpath, Main-Class et lancement -jar restent des gestes débutants séparés.

JAR n'est ni JUnit ni Records

JUnit marquait des contrôles avec @Test et comparait les valeurs attendues. Records tenaient des composants compacts affichés via des accesseurs. JAR emballe des fichiers de classes pour l'expédition et l'exécution. Ne mélangez pas ces trois rôles dans un seul fichier débutant aujourd'hui.
packed ici est le mot d'écran de la première démo depuis Pack.main dans un lancement jar avec -cp. Ce n'est pas assertEquals(5, ...) ni t.name() d'un record Tag. Quand un fichier SumCheck restant parle encore d'un 5 attendu, laissez cela comme historique et gardez la ligne d'affichage de Pack.
Sans javac, il n'y a pas de Pack.class frais à emballer. Sans jar --create, il n'y a pas de Pack.jar. Sans le chemin -cp ou -jar avec Main-Class, vous n'avez pas montré les formes de lancement de cette leçon. Gardez les annotations JUnit hors de cette page. Gardez les en-têtes record hors de cette page.

Contrôles de dossier sur la dernière page optionnelle

Listez le dossier après une création réussie. Vous devriez voir Pack.java, Pack.class et Pack.jar ensemble. Modifiez la source, enregistrez, lancez javac Pack.java, recréez le jar avec la même habitude de création, puis relancez. Un jar périmé peut masquer un affichage modifié si vous sautez la création après une édition.
Si jar se plaint d'un fichier de classe manquant, compilez d'abord. Si java -cp Pack.jar Pack n'affiche rien, confirmez que main appelle encore println. Si java -jar Pack.jar dit qu'il n'y a pas d'attribut main manifest, recréez avec --main-class Pack.
Ne collez pas @Test de SumCheck dans Pack. Ne collez pas record Tag de Card en remplacement de l'empaquetage. Le travail JAR optionnel est une archive de fichiers de classes que vous lancez avec -cp ou -jar.

Fin du parcours optionnel

Vous pouvez garder la classe publique Pack, afficher packed, compiler avec javac Pack.java, créer Pack.jar avec jar --create --file Pack.jar Pack.class, lancer java -cp Pack.jar Pack, puis afficher shipped, recréer avec --main-class Pack, et lancer java -jar Pack.jar. Le tableau sépare création, lancement classpath, Main-Class et lancement jar. C'est la dernière page optionnelle Java sur la carte du cours.
Gardez les démos Pack pour une paire d'empaquetage claire. Gardez les fichiers JUnit SumCheck hors de cette page quand vous pratiquez le jar. Gardez les fichiers Records Card hors de cette page quand vous pratiquez le jar. Gardez l'invention de nouveaux sujets optionnels hors de cette page — la carte s'arrête ici. Ces habitudes sont le point de contrôle du parcours optionnel. Quand le premier lancement montre packed ou le second montre shipped, le JAR a fait son travail pour cette leçon.
Un dernier passage dans le dossier : un Pack public, un .class correspondant, Pack.jar présent, commande de création mémorisée, lancement -cp ou -jar aligné sur la démo que vous gardez ouverte, pas d'attente Scanner, pas d'assertion requise. Compilez, recréez le jar et relancez une fois de plus sur la démo ouverte. Si l'écran montre encore packed ou shipped, la forme JAR est solide et le parcours optionnel Java est complet. Préférez une habitude d'empaquetage claire par lecture pour que chaque passage enseigne la même carte.