JAR in Java

Packe übersetzte Klassendateien in ein jar, damit du sie als eine Datei verschickst und startest. In Pack.java behältst du die öffentliche Klasse Pack, gibst aus main packed aus, übersetzt mit javac Pack.java, erstellst dann Pack.jar mit jar --create --file Pack.jar Pack.class. Starte mit java -cp Pack.jar Pack, damit der Bildschirm packed zeigt. Die zweite Demo gibt shipped aus und nutzt ein jar mit Main-Class, damit java -jar Pack.jar funktioniert. Diese Lektion ist jar-Verpackung, kein JUnit-@Test-Check und kein Records-Zugriffsdruck.

Ein jar, Start mit -cp

Öffne Pack.java. Behalte den öffentlichen Klassennamen Pack. Lösche übrig gebliebene JUnit-asserts in SumCheck, Records-Demos in Card, Streams-Pipelines in Pipe und Lambda-Schritte in Cue, wenn sie die jar-Geschichte verdecken. Die Lehrdatei ist ein kleines main-Programm, das du verpackst, keine Testklasse mit assertEquals.
In Pack.main gib ein Wort aus:
System.out.println("packed");
Übersetze zuerst:
javac Pack.java
Wenn die Klammern passen, bleibt javac still und schreibt Pack.class. Erstelle dann das jar aus der Klassendatei:
jar --create --file Pack.jar Pack.class
Starte die Klasse aus dem jar auf dem classpath:
java -cp Pack.jar Pack
Der Bildschirm zeigt packed. Du startest hier nicht java Pack aus losen Klassen. Du bittest die JVM, Pack aus Pack.jar zu laden.

Geh den Pfad einmal durch. javac Pack.java erzeugt Pack.class. jar --create --file Pack.jar Pack.class packt diese Klasse in Pack.jar. java -cp Pack.jar Pack startet Pack.main. println schreibt packed. Kein @Test läuft. Kein t.name() läuft. Kein stream().map läuft.
Sag die Anfängerregel, während du den Ordner ansiehst: Quelltext übersetzen, jar aus der .class-Datei erstellen, mit -cp und dem öffentlichen Klassennamen starten. Erfinde auf dieser Seite keine JUnit-Checks in Pack.java. Behandle jar nicht als zweiten Compiler — javac baut die Klasse; jar verpackt nur.
Wenn du noch einen grünen JUnit-Bericht aus einer SumCheck-Datei siehst, wechsle zu Pack und behalte den packed-Druck. Wenn jar meldet, dass Pack.class fehlt, übersetze erneut, bevor du das Archiv erstellst.

Main-Class-jar, Start mit -jar

Behalte dieselbe öffentliche Klasse Pack. Ändere den Druck, damit die zweite Lehrform leicht benennbar bleibt:
System.out.println("shipped");
Übersetze erneut:
javac Pack.java
Erstelle ein jar, das die Einstiegsklasse einträgt:
jar --create --file Pack.jar --main-class Pack Pack.class
Starte mit dem jar-Launcher:
java -jar Pack.jar
Der Bildschirm zeigt shipped. --main-class Pack sagt dem jar, welche öffentliche Klasse main trägt. java -jar liest diesen Einstieg und startet ihn. Behalte einen klaren Druck pro Lehrform, damit das Bildschirmwort leicht benennbar bleibt.

Geh den Pfad einmal durch. javac Pack.java erneuert Pack.class. jar --create --file Pack.jar --main-class Pack Pack.class packt die Klasse und speichert den Einstiegsnamen. java -jar Pack.jar startet Pack.main. Der Bildschirm zeigt shipped. Behalte die beiden Demos als zwei Lehrformen. Zuerst beweise einen -cp-Lauf, der packed will. Dann beweise einen -jar-Lauf, der shipped will. Beide Formen teilen öffentliche Klasse Pack und die Gewohnheit jar --create --file.
Wenn du java -jar Pack.jar auf ein jar ohne --main-class startest, scheitert der Launcher, weil keine Einstiegsklasse gespeichert ist. Dieses fehlerhafte jar ist nicht die zweite Lehrdatei. Die zweite Lehrdatei enthält --main-class Pack.

JAR-Gewohnheiten

Erstellen, classpath-Lauf, Main-Class und -jar-Lauf bleiben getrennte Anfängerschritte.

JAR ist nicht JUnit und nicht Records

JUnit markierte Checks mit @Test und verglich Erwartungswerte. Records hielten kompakte Komponenten, die du mit Zugriffen drucktest. JAR verpackt Klassendateien zum Versenden und Starten. Mische diese drei Aufgaben heute nicht in einer Anfängerdatei.
packed hier ist das Bildschirmwort der ersten Demo aus Pack.main in einem jar-Lauf mit -cp. Es ist nicht assertEquals(5, ...) und nicht t.name() aus einem Tag-record. Wenn eine SumCheck-Datei noch von erwartet 5 spricht, lass das als Historie und behalte Packs Druckzeile.
Ohne javac gibt es keine frische Pack.class zum Packen. Ohne jar --create gibt es kein Pack.jar. Ohne -cp oder einen Main-Class--jar-Pfad hast du die Laufformen dieser Lektion nicht gezeigt. Halte JUnit-Annotationen von dieser Seite fern. Halte record-Köpfe von dieser Seite fern.

Ordner-Checks auf der letzten optionalen Seite

Liste den Ordner nach erfolgreichem Erstellen. Du solltest Pack.java, Pack.class und Pack.jar zusammen sehen. Bearbeite den Quelltext, speichere, führe javac Pack.java aus, erstelle das jar mit derselben create-Gewohnheit neu, starte dann erneut. Ein altes jar kann geänderten Druck verstecken, wenn du nach einer Änderung create überspringst.
Wenn jar über eine fehlende Klassendatei klagt, übersetze zuerst. Wenn java -cp Pack.jar Pack nichts druckt, prüfe, ob main noch println aufruft. Wenn java -jar Pack.jar kein main manifest attribute meldet, erstelle neu mit --main-class Pack.
Klebe kein @Test aus SumCheck in Pack. Klebe kein record Tag aus Card als Ersatz für Verpackung. Der optionale JAR-Job ist ein Archiv von Klassendateien, das du mit -cp oder -jar startest.

Ende des optionalen Pfads

Du kannst öffentliche Klasse Pack behalten, packed drucken, mit javac Pack.java übersetzen, Pack.jar mit jar --create --file Pack.jar Pack.class erstellen, java -cp Pack.jar Pack starten, dann shipped drucken, mit --main-class Pack neu erstellen und java -jar Pack.jar starten. Die Tabelle trennt create, classpath-Lauf, Main-Class und jar-Lauf. Das ist die letzte optionale Java-Seite in der Kurskarte.
Behalte die Pack-Demos für ein klares Verpackungspaar. Halte SumCheck-JUnit-Dateien von dieser Seite fern, wenn du jar übst. Halte Card-Records-Dateien von dieser Seite fern, wenn du jar übst. Halte neue optionale Themen von dieser Seite fern — die Karte endet hier. Diese Gewohnheiten sind der Checkpoint des optionalen Pfads. Wenn der erste Lauf packed oder der zweite shipped zeigt, hat JAR seine Aufgabe in dieser Lektion erfüllt.
Ein letzter Durchgang durch den Ordner: ein öffentliches Pack, passende .class, Pack.jar vorhanden, create-Befehl im Kopf, -cp- oder -jar-Lauf passt zur Demo, die du offen hältst, kein Scanner-Warten, keine assertion nötig. Übersetze, erstelle das jar neu und starte noch einmal auf der offenen Demo. Wenn der Bildschirm noch packed oder shipped zeigt, ist die JAR-Form solide und der optionale Java-Pfad vollständig. Bevorzuge eine klare Verpackungsgewohnheit pro Durchgang, damit jeder Pass dieselbe Karte lehrt.