Für alle, die sich bereits gefragt haben, "Wie startet man eigentlich ein Java Programm?" hier die Lösung
(gefunden auf java-forum.org), eine ausführliche Zusammenstellung:
1. Ein JAVA-Archiv, so genannte "JAR-Dateien".
Generell sind alle derzeit erhältlichen großen IDEs wie bspw. Eclipse, NetBeans, JDeveloper etc. bereits mit einer Funktion zum komfortablen erzeugen einer Jar-Datei aus Quellcode ausgestattet.
Auch einige Java-Editoren bieten diese Funktion an. Darunter bspw. der Java Editor und der JCreator.
Natürlich kann man auch Jar-Dateien manuell erzeugen oder dafür ein Skript einspannen.
Um eine ausführbare Jar-Datei erzeugen zu können, muss in dem .jar-Archive eine Manifest-Datei enthalten sein (unter META-INF/MANIFEST.MF), aus der hervorgeht, welche Klasse die main-Methode enthält. Sie kann z.B. so aussehen:
Zitat: |
Manifest-Version: 1.0 Main-Class: MyProgr //LEERZEILE NICHT VERGESSEN, SONST GEHTS NICHT!! | ||||
jar cfm MyProgr.jar MyProgr.mf *.class *.jpg *.au.
Dazu gibts hier eine etwas ausführlichere Beschreibung und ein kleines Batch-Tool.
PRO
Diese Dateien sind in jedem Falle von jedem Betreibssystem ausführbar, somit bleiben die erstellten JAVA-Programme plattformunabhängig!
CONTRA
Man sollte beachten, dass man als unerfahrender Benutzer die JAR-Dateien nicht mit Programmen wie WinRar verknüpft, denn sonst kann man die Programme (JAR-Dateien) nicht mehr beim anklicken starten! Sollte man man die JAR-Datei trotzdem ausversehen mit einem Packer verknüpft haben, dann kann man JAR-Dateien (bei Windows) nur noch mittels BAT-Datei oder über START->Ausführen und dann mit "javaw -jar meine_jar_datei.jar" starten. Wem das zu umständlich ist, der muss einen Schlüssel in der Registry setzen!
Für erfahrene Leute, die wissen wie man mit der Registry unter Windows umgeht:
Man muss einen Schlüssel mit einem Binärwert unter "HKEY_CLASSET_ROOT" -> "Applications" -> "javaw.exe" -> "shell" -> "open" -> "command" eintragen mit dem Wert (Anführungszeichen mit eintragen!!!): "C:\Programme\Java\jre1.5.0_01\bin\javaw.exe" -jar "%1" %*
(Der Pfad der JRE ist natürlich bei jedem variabel, dies ist nur der Standardpfad!)
Man kann natürlich auch einfach in den Einstellungen von WinRAR unter "Integration" den Haken bei .jar Dateien entfernen, oder die .jar-Datei per rechte Maustaste -> ßffnen mit -> Java öffnen. (Edit by Illuvatar)
--------------------
2. Eine Batch-Datei (kurz .bat)
Dabei erstellt man mit dem Compiler nur die Class-Dateien. Beim klicken auf die BAT-Datei startet dann dementsprechend das eigene Programm.
Wichtig: Damit das funktioniert, muss dem System der Pfad zum JRE bekannt sein und die Bat-Datei muss im Verzeichnis der Class-Dateien liegen.
PRO
Hier ist eigentlich kein großeres PRO zu bennenen, außer dass man sein Programm jetzt mittels BAT-Datei (Stapelverarbeitungsdatei) startet. Das geht auf der Console durch Aufruf der Batchdatei oder auch per Doppelklick auf die Datei.
CONTRA
Batch-Dateien lassen sich nur von Windows aus ausführen! Außerdem kommt das mit den Bat-Dateien langsam aus der Mode, unter anderem, weil Jar-Dateien wesentlich flexibler sind.
Wenn man mal ein aktuelleres JRE installiert, funktioniert unsere Bat-Datei erst nach anpassen des Pfades zum JRE wieder.
Zitat: noctaru |
Für Linux: Code: #!/bin/sh java mein_javaprogramm Code: chmod +x Wenn man die Datei mit vollem Pfad angibt und in das /usr/local/bin verzeichnis kopiert kann man die Datei einfach nur mit dem Dateinamen(meinProgramm) aufrufen aber sonst gibt es da auch kein großartiges Pro. Contra: Das geht dann halt nur unter Linux. Aber wenn man dazu noch eine Batchdatei legt, hat man schon zwei Platformen abgedeckt. | ||||
Für Windows sieht das folgendermaßen aus:
Code:
rem * Pfad zur JRE einstellen (Bitte anpassen!) set path=.;C:\Programme\Java\jre1.6.0\bin rem * Starten einer Java-Klasse Bsp. MeinProgramm.class java MeinProgramm rem * ODER: Starten eines Programms aus einem Jar-Archiv mit Konsolenausgabe java -jar MeinProgramm.jar rem * ODER: Starten eines Programms aus einem Jar-Archiv ohne Konsolenausgabe rem javaw -jar MeinProgramm.jar
3. Programme die aus dem Bytecode Maschienencode erstellen
Dieser Maschienencode ist dann in so "EXE-Dateien" oder "DLL-Dateien" abgespeichert. Programme, die das können nennt man "NATIVE-CODE-COMPILER"!
Ein Programm was sowas kann heißt:
Excelsior JET (leider als Download nur als TRIAL-VERSION erhältlich!)
PRO
Wie gesagt es handelt sich nach der Compilierung um eine echte EXE-Datei.
Es kompiliert neben deinem eigenen Programm auch noch die gesamte JRE und erzeugt daraus eine binäre Datei.
CONTRA
Aus meiner Erfahrung her, kann ich nur sagen : "Leute lasst die Finger von sowas!". Hier die Begründung: Die Installation von Programmen wie Excelsior JET dauert bei einem 2GHz PC um die 2 Stunden, weil zunächst das JRE kompiliert wird. Die Bedienung ist meist leicht. Die Programme sind nur dann auf anderen Computern ausführbar, wenn alle Runtimes von dem entsprechenden Native-Compiler auf dem anderen PC sind (so um die 25 MB), zu den 25 MB kommt dann nochmal die gesamte JRE dazu (die als Bundle mitgeliefert wird). Das sind dann nochmal je nach JAVA-Version so um die 70 MB. Dann hat man vielleicht ein selbst geschriebenes Programm mit 200KB und 95MB Runtimes! Das lohnt sich wirklich nicht! Die Plattformunabhängigkeit geht dadurch auch verloren. Oftmals unterstützen Native Code Compiler auch nicht aktuelle JDKs.
3.1: Programme, die aus dem Quellcode Maschinencode erstellen (sog. ahead-of-time compiler)
Es gibt auch noch eine etwas einfachere Möglichkeit:
Am ehesten findet man da den GCJ, den Java Compiler aus der GNU Compiler Collection. Mit diesem ist es relativ problemlos möglich Java-Quellcode zu Maschinencode zu kompilieren:
Code:
gcj --main=Foo -o Foo Foo.java
PRO:
Es wird eine JRE-Unabhängige, ausführbare (unter Windows .exe) Datei erzeugt.
CONTRA;
Die Datei ist nicht mehr Plattform unabhängig und GJC unterstützt Teile der Java Bibliotheken noch nicht (nach eigener Angabe).
Möglichkeit 3.1 wurde vogeschlagen von cui23
--------------------
4. Programme, die den JAVA-Quellcode in C++-Quellcode umwandeln
Mit einem C++ Compiler kann man dann den C++-Quelltext zu einer EXE-Datei (Maschienencode) compilieren. Diese Variante ist also eine Art Übersetzer von Java zu C++.
Ein Programm was das kann heißt:
Ja2dol (Freeware, OpenSource-Projekt) bzw. das Nachfolge-Projekt Java2CPP
PRO
Man erhält eine lauffähige EXE-Datei, und man braucht so gut wie keine Runtime Bibliotheken. Desweiteren erhält man den in C++-Quellcode umgeformten Code des Java-Programms.
CONTRA
Wie das so mit Übersetzungstools ist, stimmt die Grammatik hinterher nicht unbedingt 100%. Das wird vor allem bei größeren Programmen sichtbar und es kommt zu Fehlern. Man sollte also auch ein wenig C++-Kentnisse haben um die Übersetzungsfehler korrigieren zu können. Die Übersetzung von "Ja2doll" ist aber schon recht akzeptabel. Die Plattformunabhängigkeit geht bei EXE-Dateien verloren.
FAZIT
Auf Grund der höhen Fehlerdichte nicht zu empfehlen für die produktive Umgebung.
-----------------------
5. Programme, die EXE-Dateien zum Starten von JAVA-Anwendungen erstellen
Dabei wird der Bytecode von einer EXE-Datei gestartet. Man hat dann neben der Jar-Datei, die die Klassen des Programms enthält, eine EXE-Datei, die das Java-Programm letztendlich startet. Man braucht also auf jeden Fall trotzdem eine JVM um die benötigten Klassen für das Java-Programm bereitzustellen.
Vertreter sind zum Beispiel JEStart von Xenoage oder Launch4J.
PRO
Per Klick auf die EXE-Datei startet das Programm, wobei das Programm (EXE-Datei) sehr klein bleibt.
Meist kann man ein Icon für die Exe-Datei festlegen.
CONTRA
Man braucht, wie oben beschrieben, eine JVM (sollte aber in der heutigen Zeit schon auf fast jedem PC drauf sein). Die Exe-Datei startet u.U. nur auf einem Windows-System. Linux-Benutzer brauchen dann wieder eine ausführbare Jar-Datei oder eine Shell-Datei zum Start.
Herzlichen Dank an Iome für den Beitrag.
Noch eine Amerkung von Ikaragua:
Zitat: Ikaragua |
Anmerkungen zum 3. Unterpunkt des Java FAQs "6 Möglichkeiten Java-Programme zu starten - .jar, .bat, .exe erstellen, von CD starten" Zunächst einmal ist es sehr einfach ausgedrückt, zu behaupten, "EXE-Dateien" sowie "DLL-Dateien" seien allgemein "Maschinencode". Das ist zwar für sich betrachtet nicht falsch, jedoch gibt es weitere Fälle bei denen der Begriff "Maschinencode" Anwendung findet, und somit nicht hierauf beschränkt genannt werden sollte. (Mir) Bekannte Native-Compiler sind der bereits genannte Excelsior JET für Windows- und Linux-Systeme sowie der GNU Compiler for Java (GCJ) der GNU Compiler Collection. Ersterer ist in der Tat kostenpflichtig und bereits in Demo-Version vollstens einsetzbar. Zweiterer ist wie vom GNU-Projekt bekannt vollständig frei und kostenlos verfügbar und auf verschiedene Systeme portiert. Allgemeine Vor- und Nachteile eines Native-Code-Programms: + Da Maschinencode, schnelle(re) Ausführung des Programms + keine "Mogelpackung" (s.u.) - Verlust der Plattformunabhänigkeit (Anm. zu 2. '+': Einigen Programmieren (auch Nutzer) behagt der Gedanke nicht, ein Programm auszuliefern, dass im eigentlichen Sinne keines ist [sondern eben Bytecode, also gewissermaßen ein eigenes computerähnliches System braucht, um ausgeführt zu werden].) Excelsior JET In der Tat ist es so, dass dem von Excelsior JET kompilierten Programm/Programmbibliothek, sollte es auf einen anderen Rechner portiert werden, (ausschließlich!) die Laufzeit-Bibliotheken (die das Programm benötigt) beigefügt werden müssen (oder es ist eine JET Installation auf dem Rechner vorhanden), um es letztendlich ausführen zu können. Tatsächlich beginnt deren Größe mit 50 MiB und steigt abhängig von den benutzten Klassen, wobei anzumerken ist, dass meine Programm-Laufzeit-Bibliotheken niemals 60 MiB überschritten haben. Es ist durchaus ein gewaltiger psychologischer Anstieg von einem 50-200 KiB großem Programm zu etwa 60 MiB Laufzeit, allerdings ist dem im Zeitalter von DSL und Terabyte-Festplatten keine allzu große Bedeutung zuzusprechen. Darüber hinaus sind die angesetzten 2 Stunden der Installation bei Weitem zu hoch. 5 Minuten maximal sind erforderlich. Wie schon genannt ist die Benutzerführung, wenn auch vom üblichen Windows-Bild abweichend, und Funktion ansprechend bzw. umfassend, was das Programm selbst gut verwendbar machen lässt, zudem kann sich das Ergebnis mehr als sehen lassen. Programmeinschränkungen gegenüber der Vollversion: Die einzigen Beschränkungen, die der "JET" hat, sind die ausgewählte Verwendbarkeitsdauer (30 Tage ohne Registrierung / 90 Tage mit) und ein kleines Hinweisfenster nach Beenden des kompilierten Programms. Andernfalls sind die Programme jederzeit einsetzbar. GNU Compiler for Java (GCJ) Zu diesem kann ich eigentlich nicht sonderlich viel sagen, da er (MinGW Windows Portierung) meine (syntaktisch korrekten) Programme bislang nicht kompilieren konnte, und ich ihn aufgrund dessen meide. Fazit: Der "JET" ist in jedem Fall einen Blick wert. Wer sich des GCJ annehmen möchte, der möge das tun, sollte aber keine allzu große Benutzerfreundlichkeit erwarten. | ||||
6. Möglichkeit - Das Java-Programm auf dem Zielrechner direkt von einer CD oder einem USB-Stick starten
Du hast ein Java-Programm, welches du gerne deinen Kunden, Freunden oder Bekannten vorstellen möchtest, weißt aber nicht, ob eine und welche JRE-Version auf deren Rechner installiert ist?
Dann kann dir diese Anleitung dabei helfen, eine CD zu erzeugen, die nach dem Einlegen ins CD-Laufwerk automatisch auf einem Windows-System dein Java-Programm startet. Das Interessante daran: Der Zielrechner braucht nicht mal eine JRE installiert zu haben, denn die brennen wir gleich mit auf die CD.
Hinweis: Ab Java 6 wird Windows 98 und Windows ME nicht mehr unterstützt, es müsste in diesem Fall also eine ältere JRE benutzt werden.
Schritt 1
Du erstellst dir auf deiner Festplatte ein temporäres Verzeichnis, in welches du zunächst dein JRE-Verzeichnis, welches durch die Installation des JREs auf deiner Festplatte angelegt wurde, hineinkopierst. Dann erstellst du in diesem temporären Verzeichnis eine Datei namens autorun.inf mit folgendem Inhalt:
Code:
[autorun] open=autostart.bat icon=icon.ico
Schritt 2
Außerdem brauchst du noch eine Batchdatei, die dein Programm startet. Am besten, du nennst sie autostart.bat.
Mit einem Texteditor erzeugst du dazu eine ganz normale Textdatei und kopierst nachfolgenen Batch-Text hinein.
Code:
@echo off rem Bitte den Pfad zur JRE anpassen! set CDJRE=.\java_vm\jre1.6.0\bin rem Start einer jar-Datei start %CDJRE%\javaw.exe -jar DeinJar.jar rem Start einer class-Datei rem start %CDJRE%\javaw.exe DeinProgramm rem Umgebungsvariable wieder löschen set CDJRE= rem Console schließen exit
Passe den Batch-Text an den ausgewiesenen Stellen an deine Gegebenheiten an und speichere die Datei nun unter dem Namen autostart.bat ab oder benenne die Datei entsprechend um.
Diese Batchdatei legst du zum Icon und der autorun.inf.
Schritt 3
Kopiere nun noch dein Programm, welches vorzugsweise eine jar-Datei sein sollte, hinzu. (Ein kleines Tool zum Erstellen ausführbarer Jar-Dateien findest du hier)
Es kann aber auch eine normale .class-Datei sein, es muss dann entsprechend die Zeile 7 der Batchdatei auskommentiert und Zeile 10 durch entfernen des remark (rem) aktiviert werden.
Auch Packages sind möglich, dementsprechend ist u.U. nur die Batchdatei anzupassen.
Schritt 4
Zur Kontrolle: Deine Verzeichnisstruktur sollte jetzt folgendermaßen aussehen:
Code:
[.]
| icon.ico
| autorun.bat
| autorun.inf
| DeinProgramm.jar
|
|__[java_vm]
|
|__[jre1.6.0]
|
|__[bin]
|
|__[lib]Schritt 5
Das Ganze brennst du nun mit einem Brennprogramm deiner Wahl als Daten-CD.
Auch zu lesen im Wiki auf Byte-Welt.de.
Weiterführende Links
Keine Kommentare:
Kommentar veröffentlichen