https://wiki.byte-welt.net/api.php?action=feedcontributions&feedformat=atom&user=L-ectron-xByte-Welt Wiki - Benutzerbeiträge [de]2026-07-07T15:15:19ZBenutzerbeiträgeMediaWiki 1.45.1https://wiki.byte-welt.net/index.php?title=Byte-Welt&diff=9554Byte-Welt2026-07-01T14:47:13Z<p>L-ectron-x: /* Weblinks */</p>
<hr />
<div>'''Byte-Welt''' ging aus einem älteren Projekt hervor, das von einigen jungen Programmierern 2004 nach wachsender Unzufriedenheit mit ihrem Lieblings-Java-Forum entstand. Damals hieß das Projekt noch '''Coding Community''' und beschäftigte sich hauptsächlich mit der Programmierung in Java. Auch ein kleines Forum und einen Entwickler-Chat gab es damals schon, beide aber wenig besucht. Einige Programmierer-Freunde verließen das Projekt, die Community schrumpfte. Im Juni 2006 wurde von [[Benutzer:EagleEye|EagleEye]] und einer Hand voll Programmierer-Freunde ein Neuanfang vereinbart. Der etwas sperrige Name wurde verworfen und Byte-Welt wurde gegründet.<br />
<br />
==Entstehung==<br />
Bei Problemen im Programmieralltag holte man sich zu deren Lösung Ideen und Anregungen aus Internet-Foren, Wikis, Chats etc. - heute häufig auch von KI-Assistenten. Die meisten Programmierer beherrschen mehrere Programmiersprachen, um ihre tägliche Arbeit bewältigen zu können und melden sich daher bei mehreren spezialisierten Communities an, die sich mit jeweils einer Programmiersprache beschäftigen.<br />
<br />
Die Idee war daher, ein Projekt zu schaffen, in dem sich Programmierer der wichtigsten Programmiersprachen unter einem Dach und mit nur einem Benutzerkonto über verschiedenste Web-Dienste austauschen können. Dieses Wiki ist demnach nur ein Teil von ''byte-welt.net''.<br />
<br />
Byte-Welt selbst versammelte IT-Experten vieler Fachrichtungen, und konnte so ein breites Spektrum abdecken. Die bis dato aktive Community bestand aus Schülern, Studenten, Fachinformatikern und Diplom-Ingenieuren. Viele Hobby-Entwickler fanden auch den Weg zu uns.<br />
<br />
Heute ist Byte-Welt zum großen Teil ein Archiv für IT-Wissen und damit ein Teil deutscher IT-Geschichte.<br />
<br />
<br />
<br />
==Inhalte==<br />
''byte-welt.net'' bestand aus einem Forum (einem heute noch aktiven Entwickler- [https://discordapp.com/invite/S4P8RAD Chat], diesem [http://wiki.byte-welt.de Wiki], der nicht mehr aktiven Java Link Base und mehreren weiteren Projekten wie bspw. das heute noch verfügbare [https://java-blog-buch.bytes4fun.de/ Java Blog Buch].<br />
<br />
<br />
{{Byte-Welt}}<br />
<br />
<br />
==Weblinks==<br />
*[[Byte-Welt_Wiki:Impressum|Impressum]]<br />
<br />
[[Kategorie:Byte-Welt]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=Hauptseite&diff=9553Hauptseite2026-07-01T14:45:46Z<p>L-ectron-x: </p>
<hr />
<div>{{Byte-Welt}}<br />
<!-- Willkommen --><br />
<center><table cellpadding="0px" cellspacing="0px" style="margin-bottom:2em;"><br />
<tr><br />
<td align="center" style="border:1px solid #2C4051; padding:0.75em; font-weight:bold; color:white; background-color:#2C4051"><h2>Willkommen im Byte-Welt-Wiki</h2></td><br />
</tr><br />
<tr><br />
<td valign="top" style="border:1px solid #2C4051; width:100%; border-top:0px; padding:0.75em; text-align:left"><h3>Was das Byte-Welt-Wiki heute ist</h3><br />
Das Byte-Welt-Wiki ist ein Archiv und Lernprojekt im Themenbereich Hardware und Programmierung. Viele Inhalte, wie Best Practice, Codestücke oder Tutorials stammen aus der aktiven Zeit der Byte‑Welt‑Community, die über Jahre ein Forum, einen Chat, dieses Wiki und das Java-Blog-Buch betrieb. Zahlreiche Beiträge wurden damals gemeinschaftlich erstellt und gepflegt – ein Stück deutschsprachiger IT‑Geschichte, die hier bewusst erhalten bleibt.<br />
<h3>Wie das Projekt weitergeführt wird</h3><br />
Das Byte-Welt-Wiki wird schrittweise modernisiert. Die Weiterentwicklung erfolgt bewusst langsam und ohne Zeitdruck. Monat für Monat kommen neue Themen hinzu oder bestehende Inhalte werden ergänzt.<br />
</td><br />
</tr><br />
</table></center><br />
<br />
<!-- Autor des Monats --><!-- Tipp --><!-- Newsflash --><br />
<table cellpadding="0px" cellspacing="0px" style="margin-bottom:2em;"><br />
<tr><br />
<!--<td align="center" style="border:1px solid #2C4051; padding:0.75em; font-weight:bold; background-color:#2C4051">Autor/-in des Monats</td><br />
<td></td>--><br />
<td align="center" style="border:1px solid #2C4051; padding:0.75em; font-weight:bold; color:white; background-color:#2C4051">Tipp</td><br />
<td></td><br />
<td align="center" style="border:1px solid #2C4051; padding:0.75em; font-weight:bold; color:white; background-color:#2C4051">Newsflash</td><br />
</tr><br />
<tr><br />
<!--<td style="border-left:1px solid #2C4051; border-right:1px solid #2C4051; width:30%; text-align:left"><table><tr><td>[[Bild: Pokal.png]]</td><td><br/>'''I'''n diesem Monat wurden folgende Autoren für gute Arbeit im Wiki ausgezeichnet:</td></tr></table></td><br />
<td></td>--><br />
<td style="border-left:1px solid #000; border-right:1px solid #000; width:30%; text-align:left"><table><tr><td>[[Bild: Gluehbirne.png]]</td><td><br/> '''F'''ür das schnelle Navigieren im Wiki bitte das [[Inhalt|Inhaltsverzeichnis]] nutzen.</td></tr></table></td><br />
<td></td><br />
<td style="border-left:1px solid #000; border-right:1px solid #000; width:30%; text-align:left"><table><tr><td>[[Bild: Newsflash.png]]</td><td>'''News aus dem Byte-Welt Themenbereich'''</td></tr></table></td><br />
<tr><br />
<td valign="top" style="border:1px solid #2C4051; width:30%; border-top:0px; padding:10px"><br />
<table align="center" style="margin-top:20px"><br />
<tr><br />
<td>{{Neuer Artikel}}</td><br />
</tr><br />
</table><br />
</td><br />
<td style="width:5%"></td><br />
<td valign="top" style="border:1px solid #2C4051; width:33%; border-top:0px; padding:10px"><br />
<ul><br />
<li><strong>Zum Jahresanfang stellte Byte-Welt den Forum-Betrieb ein!</strong></li><br />
<li>Apache NetBenas 30 erschienen</li><br />
<li>Eclipse 2026-06 erschienen</li><br />
<li>Oracle veröffentlicht Java 26 und das Update für Java SE 8 Update 491</li><br />
</ul><br />
</td><br />
</tr><br />
</table><br />
<br />
<!-- Zufallsartikeln Nr1 + 2 --><br />
<table cellpadding="0px" cellspacing="0px"><br />
<tr><br />
<td align="center" style="border:1px solid #2C4051; padding:0.75em; font-weight:bold; color:white; background-color:#2C4051">Kategorien</td><br />
</tr><br />
<tr><br />
<td valign="top" style="border:1px solid #2C4051; width:48%; border-top:0px; padding:10px"><br />
<tagcloud><br />
min_count=5<br />
</tagcloud><br />
</td><br />
</tr><br />
</table></div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=Enum_(Java)&diff=9552Enum (Java)2026-07-01T14:41:56Z<p>L-ectron-x: /* Weiterführende Links */</p>
<hr />
<div>Mit dem Schlüsselwort <code>enum</code> werden in Java Aufzählungen realisiert.<br />
<br />
Für diesen Artikel greifen wir auf eine Publikation in unserem [https://java-blog-buch.bytes4fun.de/0605-enumerations/ Java-Blog-Buch] zurück.<br />
<br />
*[https://java-blog-buch.bytes4fun.de/0605-enumerations/ Enumaration]<br />
<br />
=enum durchlaufen=<br />
Um durch die Werte einer Enumeration zu iterieren ist folgender Code praktikabel:<br />
<syntaxhighlight lang="java"><br />
public enum Day {<br />
MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY<br />
}<br />
<br />
public void iterate() {<br />
for (Day day : Day.values()) {<br />
System.out.println(day);<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
<br />
{{Fragen stellen}}<br />
<br />
[[Kategorie:Java Grundlagen]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=Enum_(Java)&diff=9551Enum (Java)2026-07-01T14:40:50Z<p>L-ectron-x: </p>
<hr />
<div>Mit dem Schlüsselwort <code>enum</code> werden in Java Aufzählungen realisiert.<br />
<br />
Für diesen Artikel greifen wir auf eine Publikation in unserem [https://java-blog-buch.bytes4fun.de/0605-enumerations/ Java-Blog-Buch] zurück.<br />
<br />
*[https://www.java-blog-buch.de/0605-enumerations/ Enumaration]<br />
<br />
=enum durchlaufen=<br />
Um durch die Werte einer Enumeration zu iterieren ist folgender Code praktikabel:<br />
<syntaxhighlight lang="java"><br />
public enum Day {<br />
MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY<br />
}<br />
<br />
public void iterate() {<br />
for (Day day : Day.values()) {<br />
System.out.println(day);<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
=Weiterführende Links=<br />
*[https://forum.byte-welt.net/t/wofuer-verwendet-ihr-enums/21046 Wofür verwendet ihr enums - wann einsetzen und wann nicht? - Byte-Welt-Forum]<br />
<br />
{{Fragen stellen}}<br />
<br />
[[Kategorie:Java Grundlagen]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=Java-Programm_nur_einmal_starten&diff=9550Java-Programm nur einmal starten2026-07-01T14:39:34Z<p>L-ectron-x: /* Einleitung */</p>
<hr />
<div>[[Kategorie:Java]]<br />
[[Kategorie:Tutorials (Java)]]<br />
<br />
=Einleitung=<br />
Unter bestimmten Umständen kann es gewünscht sein, dass nur eine aktive Instanz eines Programms auf einem Rechner ausgeführt wird. Sollte das Programm ein weiteres Mal aufgerufen werden, soll die gerade aktive, (unsichtbare) Instanz des Programms in den Fokus des Benutzers geholt werden. <br />
<br />
'''Es stellt sich also die Frage: Wie kann überprüft werden, ob ein Programm schon läuft und anschließend ein weiterer Start verhindert werden?'''<br />
<br />
Jedes Java-Programm wird in einer eigenen virtuellen Maschine (VM) gestartet, somit sind sie räumlich voneinander getrennt.<br />
Im Web sind einige interessante Vorschläge zu finden, die beschreiben, wie man ein Java-Programm so programmiert, dass nur eine aktive Instanz im Arbeitsspeicher zugelassen wird, man also ein Java-Programm nur "einmal" ausführen kann.<br />
<br />
Möglichkeiten zur Lösung gibt es. Hier einige Ansätze:<br />
* eine Lock-Datei<br />
* einen Port sperren<br />
* Client/Server-Anwendung<br />
* eine Kombination aus all dem.<br />
<br />
Jede der Lösungen bietet Vorteile, wie auch Nachteile in der Praxis. In unserem Artikel [https://java-blog-buch.bytes4fun.de/d-java-anwendung-nur-einmal-ausfuehren/ Java-Anwendung nur einmal ausführen - Java-Blog-Buch] wurden die wichtigsten beschrieben.<br />
<br />
Demnach ist einer der größten Nachteile beim Einsatz von Lock-Dateien, dass man mit einer bereits gestarteten Anwendung nicht kommunizieren kann. Man kann die laufende Instanz bspw. nicht sichtbar machen, wenn sie gerade verdeckt ist. Das Gleiche trifft auf die Port-Sperrung zu. Im schlimmsten Fall passiert also gar nichts und/oder der Bildschirm bleibt unverändert, wenn man versucht, das gewünschte Programm ein weiteres Mal zu starten.<br />
<br />
Client-/Server-Anwendungen sind meist etwas komplexer, können aber derartige Probleme lösen.<br />
<br />
Eine bisher nicht besprochene Lösung wird im Folgenden beschrieben. Eine Lösung mit Hilfe der seit dem [[JDK]] 1.0 mitgelieferten Java-Bibliothek für verteilte Anwendungen - [[RMI]].<br />
Sie besticht durch ihre Einfachheit gegenüber einer Client-/Server-Anwendung und einem Maximum an Vorteilen.<br />
<br />
=RMI - eine Einführung=<br />
Um die in diesem Artikel besprochene Lösung zu programmieren, werden keine RMI-Kenntnisse vorausgesetzt, sie werden aber beim Verstehen des Codes und der Vorgehensweise helfen, so dass später die Implementierung in eigenen Programmen leichter fällt.<br />
<br />
Daher empfehlen wir, bevor wir weiter machen, den kurz und knapp gehaltenen Einführungsartikel ([[RMI minimal]]) zu studieren.<br />
<br />
=Schritt für Schritt zum Start-Limit=<br />
Beginnen wir also nun, eine kleine Demo-Anwendung zu programmieren, mit dem Ziel, dass diese nur einmal gestartet werden kann. Weitere Starts werden nur die bereits aktive Anwendung in den Fokus des Benutzers holen.<br><br />
Wenn man es genau nimmt, wird zwar eine weitere Instanz der Anwendung gestartet werden können, jedoch nach der Kommunikation mit der bereits laufenden Instanz sofort wieder beendet.<br />
<br />
==Die Ausgangslage - ein einfaches Fenster==<br />
Zunächst möchten wir eine einfache Anwendung erzeugen, die wir dann im weiteren Schritt mit den gewünschten Funktionen ausbauen.<br />
<syntaxhighlight lang="java" line="true"><br />
import java.awt.*;<br />
import java.awt.event.*;<br />
import javax.swing.*;<br />
<br />
/**<br />
* DemoFrame ist der Einstiegspunkt in die Anwendung.<br />
* Hier werden wichtige Prüfungen angestoßen und die Benutzeroberfläche zusammengebaut.<br />
* @author Gernot Segieth<br />
*/<br />
public class DemoFrame {<br />
private JFrame frame;<br />
<br />
public DemoFrame() {<br />
frame = new JFrame("Demo-Frame");<br />
frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);<br />
frame.addWindowListener(new WindowAdapter() {<br />
public void windowClosing(WindowEvent e) {<br />
exit();<br />
}<br />
});<br />
<br />
/* Position für später einzufügenden Code aus<br />
Kapitel Zusammenspiel Server und Client */<br />
<br />
frame.add(createMainPanel());<br />
frame.pack();<br />
frame.setLocationByPlatform(true);<br />
frame.setVisible(true);<br />
}<br />
<br />
private JPanel createMainPanel() {<br />
JPanel panel = new JPanel(new BorderLayout());<br />
panel.setPreferredSize(new Dimension(600, 400));<br />
return panel;<br />
}<br />
<br />
private void exit() {<br />
int option = JOptionPane.showConfirmDialog(<br />
frame,<br />
"Möchten Sie die Anwendung wirklich beenden?",<br />
getAppTitle() + " - Beenden bestätigen",<br />
JOptionPane.YES_NO_OPTION,<br />
JOptionPane.QUESTION_MESSAGE);<br />
<br />
if (option == JOptionPane.YES_OPTION) {<br />
<br />
/* Position für später einzufügenden Code aus<br />
Kapitel Zusammenspiel Server und Client */<br />
<br />
frame.dispose();<br />
}<br />
}<br />
<br />
public static void main(String[] args) {<br />
try {<br />
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());<br />
}<br />
catch(Exception ex) {<br />
System.out.println(ex);<br />
}<br />
<br />
SwingUtilities.invokeLater(new Runnable() {<br />
public void run() {<br />
new DemoFrame();<br />
}<br />
});<br />
}<br />
}<br />
</syntaxhighlight><br />
Der Code der Anwendung ist schon für den nächsten Schritt vorbereitet, so dass in den folgenden Schritten weniger verwirrende Code-Änderungen durchgeführt werden müssen. [[Datei:Demo-Frame_01.png|300px|thumb|left|Die Ausgabe: ein leerer JFrame]]<br />
<br />
Wir erzeugen also einen leeren {{JAPI|JFrame}}.<br />
<br />
In Zeile 15 schalten wir das Standardverhalten des JFrames beim Beenden (Klick auf den Schließen-Button des Fensters) aus. Damit der JFrame geschlossen werden kann, implementieren wir anschließend (Zeile 16 bis Zeile 20) einen {{JAPI|WindowListener}}, der für die Beendigung des Programms sorgt. Man könnte das auch auch einfacher lösen, in dem man in Zeile 15 <code>frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);</code> schreiben würde. Aber wie erwähnt wird bereits ein später benötigtes Verhalten hier implementiert.<br />
<br />
In Zeile 25 fügen wir das in Zeile 31 bis Zeile 35 definierte {{JAPI|JPanel}} in dem JFrame ein. Das JPanel sorgt hier erst mal nur für die Größe des JFrames bei der Ausgabe auf dem Bildschirm. Später werden wir noch Code für das JPanel hinzufügen, der die Demo anschaulicher machen wird.<br />
<br />
In Zeile 27 legen wir fest, dass die JVM unser Fenster dort auf dem Bildschirm positionieren wird, wie es den Regeln des Host-Systems zur Ausgabe von neuen Fenstern auf dem Bildschirm entspricht.<br />
<br />
Die exit()-Methode schließt unsere Anwendung, wenn der Benutzer auf den entsprechenden Fenster-Button klickt.<br />
<br />
==Vorüberlegung==<br />
Gut, eine einfache GUI wurde aufgebaut. Später werden wir noch einige Objekte darin ablegen/einfügen, um eine sinnvollere Anwendung zu erhalten.<br />
<br />
'''Folgende Frage müssen wir uns nun beantworten: Wie muss sich ein Programm verhalten, um zu ermitteln, ob ein gleichartiges Java-Programm bereits ausgeführt wird?'''<br />
<br />
'''1.''' Wird das Programm das "erste" Mal gestartet, muss es zunächst nach einer weiteren aktiven gleichartigen Anwendung "suchen".<br><br />
'''2.''' Sollte es keine aktive gleichartige Anwendung geben, ist die soeben gestartete Instanz die erste und wird dem Benutzer auf dem Bildschirm angezeigt.<br><br />
'''3.''' Ist allerdings bereits eine gleichartige Anwendung aktiv, muss sich die zuletzt gestartete Instanz wieder beenden und die möglicherweise gerade nicht sichtbare erste Instanz in den Vordergrund des Bildschirms gebracht werden.<br />
<br />
'''Punkt 1''' klingt etwas nach dem klassischen Verhalten eines Clients. Er sucht nach einem Server, um seine Dienste zu nutzen.<br><br />
'''Punkt 2''' klingt nach dem Verhalten eines Servers. Er wird gestartet und bietet Dienste für Clients an, die sich mit ihm verbinden.<br><br />
'''Punkt 3''' klingt nach einer Interaktion von Client und Server. Der Client hat einen Server "gefunden", nutzt einen Dienst (''zeige die Benutzeroberfläche an'') und beendet die Verbindung bzw. sich selbst.<br />
<br />
Das bedeutet, wir benötigen in unserem Programm das Verhalten eines Servers und eines Clients.<br />
<br />
Und genau dieses Verhalten werden wir nun schrittweise mit Hilfe von [[RMI]] implementieren.<br />
<br />
==Definition des Remote-Interfaces==<br />
Hier nun also die Definition unseres Remote-Interfaces, welches alle Methodenrümpfe enthält, die unser Programm für das gewünschte Verhalten benötigt.<br />
<br />
<syntaxhighlight lang="java"><br />
import java.rmi.Remote;<br />
import java.rmi.RemoteException;<br />
<br />
/**<br />
* Das Interface beschreibt die benötigten Methoden, die von einem RemoteTask implementiert werden müssen.<br />
* @author Gernot Segieth<br />
*/<br />
public interface RemoteTask extends Remote {<br />
<br />
/**<br />
* Wird prüfen, ob bereits ein RMI-Server online ist.<br />
* Der RMI-Server ist online, wenn bspw. der RMI-Port (1099) belegt ist, ein Remote-Objekt <br />
* in der RMI-Registry gespeichert wurde und eine Methode dieses Objektes aufgerufen werden kann.<br />
* @return <code>true</code>, wenn festgestellt werden konnte, dass der RMI-Server bereits online ist,<br />
* sonst <code>false</code>.<br />
* @throws java.rmi.RemoteException<br />
*/<br />
boolean isRunningAnotherInstance() throws RemoteException;<br />
<br />
/**<br />
* Wird die Benutzeroberfläche der bereits laufenden Programminstanz anzeigen.<br />
* @throws java.rmi.RemoteException<br />
*/<br />
void showRunningInstance() throws RemoteException;<br />
<br />
}<br />
</syntaxhighlight><br />
<br />
Die erste Methode wird also zur Ermittlung eines laufenden Servers benötigt, die Zweite, um die laufende (erste) Instanz sichtbar zu machen.<br />
<br />
==Implementierung der Remote-Funktionen==<br />
Die entsprechende Ausprogrammierung (Implementierung), der von unserem Remote-Interface vorgegebenen Methoden, sieht für unsere Anwendung nun so aus:<br />
<br />
<syntaxhighlight lang="java"><br />
import java.awt.Frame;<br />
import java.rmi.RemoteException;<br />
<br />
/**<br />
* RemotTaskImpl enthält die Aufgaben des RMI-Servers in Form von ausprogrammierten Methoden des Remote-Interfaces.<br />
*/<br />
public class RemoteTaskImpl implements RemoteTask {<br />
private final Frame frame;<br />
<br />
/**<br />
* Der RMI-Server kennt die laufende (erste) Anwendung und übergibt hier die Fenster-Instanz,<br />
* die in den Fokus des Benutzers geholt werden soll, wenn eine weitere gleichartige Anwendung<br />
* gestartet werden sollte.<br />
* @param frame Die Benutzeroberfläche der "ersten" Instanz.<br />
*/<br />
public RemoteTaskImpl(Frame frame) {<br />
this.frame = frame;<br />
}<br />
<br />
/**<br />
* Diese Methode kann vom Client nur aufgerufen werden, wenn ein RMI-Server aktiv ist<br />
* und von diesem das entsprechende Remote-Objekt bereitgestellt wurde.<br />
* Ist diese Methode aufrufbar, heißt das für den Client, dass bereits eine gleichartige<br />
* Anwendung aktiv ist.<br />
* @see RemoteTask<br />
* @return <code>true</code> wenn bereits eine andere, gleichartige Instanz aktiv ist.<br />
* @throws RemoteException <br />
*/<br />
@Override<br />
public boolean isRunningAnotherInstance() throws RemoteException {<br />
System.out.println("A second instance of " + frame.getTitle() + " was started.");<br />
return true;<br />
} <br />
<br />
/**<br />
* Diese Methode wird vom RMI-Client aufgerufen, um dem RMI-Server mitzuteilen, dass er<br />
* die bereits laufende Instanz in den Fokus des Benutzers holen soll.<br />
* @see RemoteTask<br />
* @throws RemoteException <br />
*/<br />
@Override<br />
public void showRunningInstance() throws RemoteException {<br />
System.out.println("The instance of " + frame.getTitle() + " that is already running is displayed.");<br />
frame.pack();<br />
frame.setLocationRelativeTo(null);<br />
frame.setVisible(true);<br />
frame.toFront();<br />
}<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
==Implementieren des Servers==<br />
<br />
<syntaxhighlight lang="java"><br />
import java.awt.Frame;<br />
import java.rmi.AlreadyBoundException;<br />
import java.rmi.NoSuchObjectException;<br />
import java.rmi.NotBoundException;<br />
import java.rmi.RemoteException;<br />
import java.rmi.registry.LocateRegistry;<br />
import java.rmi.registry.Registry;<br />
import java.rmi.server.UnicastRemoteObject;<br />
<br />
/**<br />
* Server ist der RMI-Server, der Remote-Objekte in der RMI-Registry speichert<br />
* und Anfragen von Clients beantwortet.<br />
* Die Klasse erwartet mindestens die Instanz der Fenster-Klasse, das als Single-Fenster behandelt werden soll.<br />
*<br />
* @author Gernot Segieth<br />
*/<br />
public class Server {<br />
private RemoteTaskImpl task;<br />
private String bindName;<br />
<br />
/**<br />
* Erzeugt einen RMI-Server.<br />
* Die übergebene Fenster-Instanz wird bei Bedarf sichtbar gemacht.<br />
* @param frame Die Instanz der Fenster-Klasse, die sichtbar gemacht werden soll.<br />
* @throws RemoteException<br />
* @throws AlreadyBoundException <br />
*/<br />
public Server(Frame frame) throws RemoteException, AlreadyBoundException {<br />
this(frame, Registry.REGISTRY_PORT);<br />
} <br />
<br />
public Server(Frame frame, int port) throws RemoteException, AlreadyBoundException {<br />
this.bindName = frame.getTitle();<br />
LocateRegistry.createRegistry(port);<br />
System.out.println(bindName+" listening on port " + port + "...");<br />
<br />
task = new RemoteTaskImpl(frame);<br />
RemoteTask stub = (RemoteTask) UnicastRemoteObject.exportObject(this.task, 0);<br />
<br />
Registry registry = LocateRegistry.getRegistry();<br />
registry.bind(this.bindName, stub);<br />
<br />
System.out.println("Remote object bound to RMI registry.");<br />
}<br />
<br />
/**<br />
* Entfernt das Remote-Objekt aus der RMI-Registry.<br />
* Der RMI-Server wird damit heruntergefahren.<br />
* @throws NoSuchObjectException <br />
* @throws java.rmi.NotBoundException <br />
*/<br />
public void shutDown() throws NoSuchObjectException, RemoteException, NotBoundException {<br />
UnicastRemoteObject.unexportObject(this.task, true);<br />
Registry registry = LocateRegistry.getRegistry();<br />
registry.unbind(this.bindName);<br />
System.out.println("All services have ended.");<br />
}<br />
<br />
/**<br />
public static void main(String[] args) throws RemoteException, AlreadyBoundException {<br />
Server server = server = new Server("rmi://localhost/SingleWindow");<br />
}<br />
*/<br />
}<br />
</syntaxhighlight><br />
<br />
==Implementieren des Clients==<br />
<br />
<syntaxhighlight lang="java"><br />
import java.rmi.NotBoundException;<br />
import java.rmi.RemoteException;<br />
import java.rmi.registry.LocateRegistry;<br />
import java.rmi.registry.Registry;<br />
import java.util.logging.Level;<br />
import java.util.logging.Logger;<br />
<br />
/**<br />
* Client ist der RMI-Client, der nach passenden Remote-Objekten in der RMI-Registry sucht<br />
* und die bereit gestellten Methoden für Anfragen an den Server aufruft.<br />
* Die Klasse erwartet mindestens die URI (Adresse), unter der nach Remote-Objekten gesucht werden soll.<br />
* @author Gernot Segieth<br />
*/<br />
public class Client {<br />
<br />
private RemoteTask task;<br />
<br />
public Client(String taskName) throws RemoteException {<br />
this(taskName, Registry.REGISTRY_PORT);<br />
}<br />
<br />
public Client(String taskName, int port) throws RemoteException {<br />
try {<br />
Registry registry = LocateRegistry.getRegistry(port);<br />
task = (RemoteTask) registry.lookup(taskName);<br />
} catch (RemoteException | NotBoundException ex) {<br />
Logger.getLogger(Client.class.getName()).log(Level.SEVERE, null, ex);<br />
}<br />
}<br />
<br />
/**<br />
* Ermittelt, ob bereits ein anderer RMI-Server online ist.<br />
*<br />
* @return <code>true</code>, wenn festgestellt werden konnte, dass bereits<br />
* eine RMIRegistry bzw. ein RMI-Server gestartet wurde, sonst <code>false</code>.<br />
* @throws RemoteException<br />
*/<br />
public boolean isRunningAnotherInstance() throws RemoteException {<br />
return task.isRunningAnotherInstance();<br />
}<br />
<br />
public void showRunningInstance() throws RemoteException {<br />
task.showRunningInstance();<br />
} <br />
<br />
/**<br />
public static void main(String[] args) throws RemoteException {<br />
Client client = new Client("rmi://localhost/SingleWindow");<br />
}<br />
*/<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
==Zusammenspiel Server und Client==<br />
Nehmen wir uns an dieser Stelle noch mal die eingangs geschriebene Fenster-Klasse vor.<br />
<br />
In die dort markierte Position im Code fügen wir folgendes Fragment ein:<br />
<br />
<syntaxhighlight lang="java"><br />
try {<br />
System.out.println(frame.getTitle() + " is starting... ");<br />
Server server = new Server(frame, port);<br />
} catch (RemoteException | AlreadyBoundException ex) {<br />
System.err.out(ex);<br />
try {<br />
Client client = new Client(frame.getTitle(), port);<br />
boolean isRunning = client.isRunningAnotherInstance();<br />
System.out.println("The second instance of " + frame.getTitle() + " is ended.");<br />
if (isRunning) {<br />
client.showRunningInstance();<br />
System.exit(0);<br />
}<br />
} catch (RemoteException re) {<br />
System.err.out(re);<br />
JOptionPane.showMessageDialog(null,<br />
frame.getTitle() + " kann nicht gestartet werden, weil der Port " + port + " bereits von einer anderen Anwendung benutzt wird!",<br />
re.getClass().getName(),<br />
JOptionPane.ERROR_MESSAGE);<br />
System.out.println(frame.getTitle() + " is ended.");<br />
System.exit(0);<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
Außerdem ändern wir noch die private Methode zum Beenden unseres Programms. In die '''exit()-Methode''' setzen wir folgendes Fragment an die markierte Position:<br />
<br />
<syntaxhighlight lang="java"><br />
try {<br />
server.shutDown();<br />
server = null;<br />
System.out.println(frame.getTitle() + " is down.");<br />
} catch (RemoteException | NotBoundException ex) {<br />
System.err.out(ex);<br />
}<br />
</syntaxhighlight><br />
<br />
Was passiert hier nun? Zunächst erzeugen wir ein Server-Objekt. Den Code dazu haben wir weiter oben bereits fertig gestellt. Der Server erwartet die Fenster-Instanz '''dieses''' gerade gestarteten Programms, sowie den Port (standardmäßig 1099), an dem er auf nachfolgende Programm-Instanzen warten soll. Aus der Fenster-Instanz entnimmt der Server den Titel des Frames und benutzt ihn zur Registrierung des Remote-Objektes.<br />
<br />
Ist der Port, an dem der Server lauschen soll allerdings bereits belegt, ''kann'' das bedeuten, dass der Port von einer früher gestarteten Programm-Instanz belegt wurde. Daher wird eine Fehlermeldung in die Console geschrieben und eine Instanz eines Clients angelegt. In der RMI-Fehlermeldung wird u.a. angegeben, dass der Port bereits gebunden wurde. Das ist aber in diesem Fall kein Problem. Wir konnten damit rechnen, dass bereits ein Programm dieses (unseres) Typs früher gestartet wurde.<br />
<br />
Der Client erwartet den Titel der Fenster-Klasse, den er zum Vergleich an den Server übergibt. Wurde ein Remote-Objekt unter dem Namen unserer Fenster-KLasse in der RMIRegistry abgelegt, handelt es sich dabei um ein von uns früher gestartes Programm. Der Client fragt nun beim Server nach, ob es bereits ein registriertes Remote-Objekt gibt. Eine Ausgabe zum Ergebnis dieser Anfrage wird in die Console geschrieben.<br />
<br />
Meldet der Server, dass es eine laufende Instanz unserer Fenster-Klasse gibt, bittet der Client den Server, diese Instanz im Vordergrund des Bildschirms anzuzeigen. Danach beendet sich der Client.<br />
<br />
In die exit()-Methode setzen wir an der markierten Position das 2. Fragement. Damit wird der Server vor dem Beenden herunter gefahren. Er löst die Port-Bindung und löscht das Remote-Objekt aus der RMIRegistry.<br />
<br />
Das war's. Nun testen wir. Also Code kompilieren und Anwendung starten.<br />
<br />
==Testen der Anwendung==<br />
{{In Arbeit}}<br />
<br />
==Ausbau der Anwendung==<br />
<br />
=Problem mit dieser Lösung=<br />
Wie wir gesehen haben, eröffnen sich Möglichkeiten für Probleme bei der Anwendung von RMI in unserer Anwendung. <br />
<br />
*Zunächst kann man nicht vorhersehen, ob der von uns verwendete Port nicht schon von einer anderen Software belegt wurde. In diesem Fall bekommen wir nichts von unserem Programm zu sehen. Aber auch, wenn wir nur den RMI-Port benutzen, lauern hier weitere Stolperdrähte.<br />
*Was passiert eigentlich, wenn wir mehrere Programme geschrieben haben, die alle diese nette Funktion des "Nur-einmal-startens" unterstützen? Man könnte zwar für jedes unserer Programme einen eigenen/anderen Port verwenden. Aber da gibt es sicher auch Grenzen.<br />
<br />
==Lösung des Problems==<br />
{{In Arbeit}}<br />
<br />
{{Fragen stellen}}</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=Java-Programme_durch_PlugIns_erweitern&diff=9549Java-Programme durch PlugIns erweitern2026-07-01T14:38:32Z<p>L-ectron-x: /* Weblinks */</p>
<hr />
<div>{| align=center border=0 cellpadding=3 cellspacing=3 style="border: 1px solid #E0E0E0; background-color: #F8F8F8"<br />
|- <br />
| style="font-size: 90%" | [[Bild:Unvollstaendig.png]] Dieser Artikel ist unvollständig. Hilf mit ihn zu verbessern, erweitere ihn oder beteilige dich an der Diskussion.<br />
|}<br />
<br />
Damit [[Programm]]e leicht um neue Teile erweitert werden können, ist es hilfreich und komfortabel, diese mit einer [[Plugin]]-[[Schnittstelle]] auszustatten.<br />
<br />
==Voraussetzungen==<br />
Als Voraussetzung für die Verwendung von Plugins sollten verschiedene [[Klasse]]n und [[Interface (Java) | Interface]]s vorhanden sein:<br />
# '''Plugin-Interface''' - das die Plugins implementieren müssen. Hiermit wird festgelegt welche Funktionen das Plugin der Anwendung anbieten muss.<br />
# '''Anwendung-Interface''' - das die Schnittstelle von den Plugins zur [[Anwendung]] darstellt, hiermit kann kontrolliert werden, was die Anwendungen dürfen und was sie sehen.<br />
# '''Manager''' - gesonderte Klasse für das Laden, Starten und Beenden der Plugins.<br />
<br />
==Die Interfaces==<br />
Das gesamte Plugin-System könnte auch ohne Interfaces geschrieben werden, jedoch ist dies unsicherer. Interfaces standardisieren durch vordefinierte Methoden die Entwicklung und Verwendung von Klassen, was innerhalb der Anwendung sicher stellt, dass nachgerüstete Klassen alle benötigten Methoden bereit stellen. Dadurch ist mit einfachen Mitteln eine gewisse Vielgestaltigkeit möglich.<br />
<br />
===Das Plugin-Interface===<br />
Das Interface für die Plugins muss keine Methoden (Markerinterface), kann aber auch beliebig viele definieren. Es hat sich bewärt, dass das Plugin-Interface mindestens zwei Methoden besitzt '''start()''' und '''stop()'''. Außerdem eine Methode um die Manager-Klasse zu setzen, sollte das Plugin auf irgendwelche Eigenschaften der Anwendung zugreifen können.<br />
<syntaxhighlight lang="java"><br />
package net.byte_welt.wiki;<br />
public interface PluginInterface{<br />
public boolean start();<br />
public boolean stop();<br />
public void setPluginManager(PluginManager manager);<br />
public void hello();<br />
}<br />
</syntaxhighlight><br />
Zusätzlich wurde das Interface um die Methode ''hello'' erweitert, somit kann das Plugin von der Anwendung auch benachrichtigt werden.<br />
<br />
===Das PluginManager-Interface===<br />
Das Interface für den Pluginmanager bildet die Schnittstelle vom Plugin zur Anwendung. Hier werden alle Methoden aufgeführt die das Plugin aufrufen darf.<br />
<syntaxhighlight lang="java"><br />
package net.byte_welt.wiki;<br />
public interface PluginManager{<br />
public void openWindow(String msg);<br />
}<br />
</syntaxhighlight><br />
Unser Plugin-Manager erlaubt nur das Öffnen eines Fensters mit einem String als Nachricht.<br />
<br />
==Implementierungen==<br />
Durch die Interfaces muss für die Entwicklung des Plugins nur die [[Class-Datei | Class]]- oder [[Java-Dateien]] weiter gegeben werden, die [[Implementierung]]en des PluginManagers dagegen nicht.<br />
<br />
===Hello-Plugin===<br />
Unser Plugin soll beim Aufruf der ''hello()''-Methode nur ein Fenster öffnen und dort ''Hallo'' ausgeben, daher fällt die Implementierung sehr einfach aus. Die ''start()''- und ''stop()''-Methoden werden garnicht benötigt, würde der Text aus einer [[Datenbank]] oder [[Datei]] gelesen werden könnte dies in der ''start''-Methode erledigt werden<br />
<syntaxhighlight lang="java"><br />
package net.byte_welt.wiki;<br />
public class HelloPlugin implements PluginInterface{<br />
private PluginManager manager;<br />
public boolean start(){<br />
System.out.println("ich starte");<br />
return true;<br />
}<br />
public boolean stop(){<br />
System.out.println("ich stoppe");<br />
return true;<br />
}<br />
public void setPluginManager(PluginManager manager){<br />
this.manager = manager;<br />
}<br />
public void hello(){<br />
manager.openWindow("hallo");<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
===PluginManager===<br />
Der Plugin-Manager kann für zwei Aufgaben verwendet werden. Er kann dem Plugin übergeben werden und zusätzlich kann er die Kontrolle der Plugins übernehmen. Unser Pluginmanager übernimmt beide Aufgaben, daher implementiert er das PluginManager-Interface. Zusätzlich werden die [[Methode|Methoden]] ''loadPlugin'', ''start'' und ''stop'' implementiert.<br />
<syntaxhighlight lang="java"><br />
package net.byte_welt.wiki;<br />
import java.io.*;<br />
import java.util.jar.*;<br />
import java.net.*;<br />
<br />
public class PluginManagerImpl implements PluginManager{<br />
<br />
private List<PluginInterface> loadedplugins = new ArrayLIst<>();<br />
<br />
public void start(){<br />
//..<br />
}<br />
public void stop(){<br />
//..<br />
}<br />
public void loadPlugin(File file){<br />
//..<br />
}<br />
public void openWindow(String msg){<br />
//..<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
====Start-Methode====<br />
Die ''start''-Methode wird aufgerufen, wenn die Anwendung gestartet wird und alle vorhandenen Plugins geladen werden sollen. Die Pfade zu den vorhandenen Plugins lassen sich z.B. extra speichern, oder es wird gesagt, alles was im Ordner '''plugins''' liegt gilt als Plugin. In unserem Fall wird gesagt, was im Ordner '''plugins''' liegt wird geladen, dafür wird nur die ''loadPlugin''-Methode aufgerufen.<br />
<syntaxhighlight lang="java"><br />
public void start(){<br />
File[] files = new File("plugins").listFiles();<br />
for(File f : files)<br />
loadPlugin(f);<br />
for(PluginInterface pi : loadedplugins)<br />
pi.start();<br />
}<br />
</syntaxhighlight><br />
Sind alle Plugins geladen, werden sie gestartet.<br />
<br />
====Stop-Methode====<br />
Mit der ''stop''-Methode wird den Plugins signalisiert, dass sie herunterfahren sollen. Dies ist der Fall, wenn z.B. das Programm beendet wird.<syntaxhighlight lang="java"><br />
public void stop(){<br />
for(PluginInterface pi : loadedplugins)<br />
pi.stop();<br />
}<br />
</syntaxhighlight><br />
<br />
====LoadPlugin-Methode====<br />
Um Plugins zu laden, gibt es zwei Ansätze. Zum einen gibt es die Möglichkeit [[Class-Datei|Class-Dateien]] aber auch [[JAR-Datei|JAR-Dateien]] zu laden.<br />
<br />
=====JAR-Dateien laden=====<br />
Um ein Plugin aus einer JAR-Datei zu laden, muss deren Pfad und die [[Main-Class]] bekannt sein. Im Gegensatz zu einer normalen Anwendung ist die Main-Class bei einem Plugin die [[Klasse]], die das [[Interface]] für die Plugin-Schnittstelle implementiert. Es ist aber auch möglich, alle Klassen der JAR zu durchlaufen.<br />
<syntaxhighlight lang="java"><br />
//Erzeugen des JAR-Objekts durch die Eingabe der eingelesenen File in file<br />
JarFile file = new JarFile(file);<br />
//Laden der MANIFEST.MF<br />
Manifest manifest = file.getManifest();<br />
// auslesen der Attribute aus der Manifest<br />
Attributes attrib = manifest.getMainAttributes();<br />
// holen der Mainclass aus den Attributen<br />
String main = attrib.getValue(Attributes.Name.MAIN_CLASS);<br />
</syntaxhighlight><br />
<br />
Aus dem [[JAR-Datei#MANIFEST.MF|Manifest]]-Objekt lassen sich jetzt beliebige Daten auslesen, jedoch werden hier nur die Informationen über die Main-Class benötigt. Mit diesen Daten lässt sich jetzt das Plugin laden, dazu wird ein neuer [[ClassLoader (Java) |ClassLoader]] erzeugt.<br />
<syntaxhighlight lang="java"><br />
//Festlegen wo das PluginInterface liegt<br />
String PLUGININTERFACECLASS_STRING = "net.byte_welt.wiki.PluginInterface";<br />
// Laden der Datei und Konvertierung von einer Datei, zu einer URI und dann zu einer URL<br />
URL urlFile = file.toURI().toURL();<br />
// Laden der Klasse durch den URLClassLoader<br />
URLClassLoader classLoader = new URLClassLoader(new URL[] { urlFile });<br />
// Class aus dem classLoader holen<br />
Class cl = classLoader.loadClass(main);<br />
// Interfaces aus der Klasse holen, die dort impementiert sind<br />
Class[] interfaces = cl.getInterfaces();<br />
// Durchlaufen durch die Interfaces der Klasse und nachsehen ob es das passende Plugin implementiert<br />
boolean isplugin = false;<br />
for(int y = 0; y < interfaces.length && !isplugin; y++)<br />
if(interfaces[y].getName().equals(PLUGININTERFACECLASS_STRING))<br />
isplugin = true;<br />
if(isplugin){<br />
PluginInterface plugin = (PluginInterface) cl.newInstance();<br />
loadedplugins.add(plugin);<br />
}<br />
<br />
//Schließen von JarFile und ClassLoader um Fehler zu vermeiden<br />
//jarFile.close();<br />
classLoader.close();<br />
</syntaxhighlight><br />
Anschließend werden die Interfaces der Klasse betrachtet, ob es sich wirklich um ein Plugin handelt. Ist es ein Plugin wird eine neue Instanz erzeugt und diese abgespeichert.<br />
<br />
=====JAR-Dateien laden (Die Methode komplett)=====<br />
Um ein Plugin aus einer JAR-Datei zu laden, muss deren Pfad und die [[Main-Class]] bekannt sein. Im Gegensatz zu einer normalen Anwendung ist die Main-Class bei einem Plugin die [[Klasse]], die das [[Interface]] für die Plugin-Schnittstelle implementiert. Es ist aber auch möglich, alle Klassen der JAR zu durchlaufen.<br />
<syntaxhighlight lang="java"><br />
<br />
//Festlegen wo das PluginInterface liegt<br />
private static final String PLUGININTERFACECLASS_STRING = "net.byte_welt.wiki.PluginInterface";<br />
<br />
public void loadPlugin(File file) {<br />
try {<br />
// Erzeugen des JAR-Objekts durch die Eingabe der eingelesenen File in file<br />
JarFile jarFile = new JarFile(file);<br />
// Laden der MANIFEST.MF<br />
Manifest manifest = jarFile.getManifest();<br />
// Auslesen der Attribute aus der Manifest-Datei<br />
Attributes attrib = manifest.getMainAttributes();<br />
// Mainclass aus den Attributen laden<br />
String main = attrib.getValue(Attributes.Name.MAIN_CLASS);<br />
// Laden der Datei und Konvertierung von einer Datei, zu einer URI und dann zu<br />
// einer URL<br />
URL urlFile = file.toURI().toURL();<br />
// Laden der Klasse durch den URLClassLoader<br />
URLClassLoader classLoader = new URLClassLoader(new URL[] { urlFile });<br />
// Class aus dem classLoader holen<br />
Class cl = classLoader.loadClass(main);<br />
// Interfaces aus der Klasse holen, die dort impementiert sind<br />
Class[] interfaces = cl.getInterfaces();<br />
// Durchlaufen durch die Interfaces der Klasse und nachsehen ob es das<br />
// PluginInterface implementiert und somit ein Plugin ist<br />
boolean isplugin = false;<br />
for (int y = 0; y < interfaces.length && !isplugin; y++)<br />
if (interfaces[y].getName().equals(PLUGININTERFACECLASS_STRING))<br />
isplugin = true;<br />
// Wenn es ein Plugin ist, dann lade die Datei bzw. das Plugin<br />
if (isplugin) {<br />
PluginInterface plugin = (PluginInterface) cl.newInstance();<br />
// Zu den geladenen Plugin hinzufügen<br />
loadedplugins.add(plugin);<br />
}<br />
// Schließen von JarFile und ClassLoader um Fehler zu vermeiden<br />
jarFile.close();<br />
classLoader.close();<br />
} catch (ClassNotFoundException | InstantiationException | IllegalAccessException | IOException e) {<br />
System.out.println("Plugin konnte nicht geladen werden!");<br />
e.printStackTrace();<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
=====Class-Dateien laden=====<br />
* wird nachgeliefert.<br />
<br />
===OpenWindow-Methode===<br />
Die ''openWindow''-Methode ist für die Interaktion mit den Plugins nötig, über diese Methode kann ein Fenster geöffnet werden.<br />
<syntaxhighlight lang="java"><br />
public void openWindow(String msg){<br />
javax.swing.JOptionPane.showMessageDialog(null, msg);<br />
}<br />
</syntaxhighlight><br />
<br />
=Weblinks=<br />
*[https://java-blog-buch.bytes4fun.de/d-plugin-entwicklung-in-java/ Java Blog Buch: Plugin-Entwicklung in Java]<br />
<br />
<br />
[[Kategorie:Tutorials (Java)]]<br />
[[Kategorie:Java]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=JAR-Datei&diff=9548JAR-Datei2026-07-01T14:37:46Z<p>L-ectron-x: /* Links */</p>
<hr />
<div>Eine JAR-Datei ('''''J'''ava '''Ar'''chive''), ist ein Archiv, welches auf dem [[ZIP]]-Format basiert. JAR-Dateien sind also identisch mit ZIP-Dateien, sind aber um einen Ordner ''META-INF'' erweitert, der dem Interpreter weitere Informationen zur JAR-Datei liefert.<br />
<br />
JAR-Dateien werden verwendet, um die einzelnen Dateien eines Projekts zusammen zufassen. So sind in einem Archiv häufig neben [[Class]]-Dateien auch multimediale Inhalte zu finden (Bilder, Sound etc.).<br />
<br />
Daher unterscheiden wir JAR-Dateien in Java-Anwendungen und Java-Biliotheken, die wiederum Java-Anwendungen um Funktionen erweitern.<br />
<br />
Enthält eine JAR-Datei ein Verzeichnis META-INF mit einer Manifest-Datei mit einem Eintrag für eine Startklasse (Main-Class), kann eine die JAR-Datei bei passender JRE per Mausklick gestartet werden.<br />
<br />
=META-INF=<br />
Der META-INF Ordner enthält immer eine Datei MANIFEST.MF, in dieser werden Informationen über das Archiv bzw. das Programm beschrieben.<br />
<br />
Wenn eine JAR-Datei [[Java-Applets und Java WebStart-Anwendungen signieren|signiert]] wird, wird automatisch eine Signaturdatei generiert und im META-INF- Verzeichnis der JAR-Datei abgelegt , das auch das Manifest des Archivs enthält. Signaturdateien haben Dateinamen mit der Erweiterung .SF . Außerdem eine Signaturblock-Datei mit der Dateiendung .DSA.<br />
<br />
Die Mindestausführung einer Manifest-Datei sieht bspw. so aus:<br />
Manifest-Version: 1.0 <br />
Main-Class: HelloWorld <br />
[LEERZEILE]<br />
<br />
==MANIFEST.MF==<br />
In der Manifest-Datei werden verschiedene Eigenschaften beschrieben. Die Eigenschaften werden durch einen Tupel von Schlüsselwort und Wert angegeben.<br />
Für verschiedene Bereiche der Verwendung, sind auch verschiedene Eigenschaften vorgesehen:<br />
{| {{Prettytable}}<br />
! Bereich<br />
! Attribut<br />
! Beschreibung<br />
! Optional<br />
|-<br />
| Allgemein<br />
| Manifest-Version<br />
| Versionsnummer für die Manifest-Datei<br />
| Nein<br />
|-<br />
|<br />
| Created-By<br />
| Optionale Angabe des Erstellers<br />
| Ja<br />
|-<br />
|<br />
| Name<br />
| Angabe des Namens einer Datei, z.B. für eine Signatur oder Bean<br />
| Ja<br />
|-<br />
|<br />
| SHA1-Digest<br />
| SHA1 Signatur für die darüber angegebene Datei<br />
| Ja<br />
|-<br />
|<br />
| Signature-Version<br />
| Definiert die Version der Signatur<br />
| Ja<br />
|-<br />
|<br />
| Class-Path<br />
| Angabe von Klassen und JAR-Dateien, die zum [[Classpath]] hinzugefügt werden sollen, sie sollten immer mit ./ beginend angegeben werden<br />
| Ja<br />
|-<br />
|<br />
| Permissions<br />
| Seit Java 7 Update 51 ist die Permissions-Angabe anzugeben. Gültig sind <code>sandbox</code> (keine Rechteerweiterung benötigt) und <code>all-permissions</code> (z.B. für Schreib-/Leserechte). (Mehr dazu unter [https://docs.oracle.com/javase/8/docs/technotes/guides/deploy/manifest.html#A1148525 Permissions])<br />
| Nein (nur für Applets und WebStart)<br />
|-<br />
|<br />
| Application-Name<br />
| Hier muss der Name der Anwendung angegeben werden. (Mehr dazu unter [https://docs.oracle.com/javase/8/docs/technotes/guides/deploy/manifest.html#A1148568 Application-Name])<br />
| Nein (nur für Applets und WebStart)<br />
|-<br />
|<br />
| Codebase<br />
| Hier muss die Quell-Domain, also der Herkunftsort angegeben werden. (Mehr dazu unter [https://docs.oracle.com/javase/8/docs/technotes/guides/deploy/manifest.html#CIHJIIHD Codebase])<br />
| Nein (nur für Applets und WebStart)<br />
|-<br />
| Anwendungen<br />
| Main-Class<br />
| Angabe der Mainclass, sie ist nötig wenn die JAR-Datei ausführbar sein soll<br />
| Ja (wenn es kein ausführbares Programm ist)<br />
|-<br />
|<br />
| SplashScreen-Image<br />
| Angabe eines Bildes, das als Splash-Screen angezeigt wird. Das Bild muss in der JAR vorhanden sein.<br />
| Ja<br />
|-<br />
| Applets<br />
| Extension-List<br />
| <br />
|<br />
|-<br />
| <br />
| *-Extension-Name<br />
|<br />
|<br />
|-<br />
| <br />
| *-Specification-Version<br />
|<br />
|<br />
|-<br />
| <br />
| *-Implementation-Version<br />
|<br />
|<br />
|-<br />
| <br />
| *-Implementation-Vendor-Id<br />
|<br />
|<br />
|-<br />
| <br />
| *-Implementation-URL<br />
|<br />
|<br />
|-<br />
| Extensions<br />
| Extension-Name<br />
|<br />
|<br />
|-<br />
| <br />
| Implementation-Title<br />
|<br />
|<br />
|-<br />
| <br />
| Implementation-Vendor<br />
|<br />
|<br />
|-<br />
| <br />
| Implementation-Vendor-Id <br />
|<br />
|<br />
|-<br />
| <br />
| Implementation-URL<br />
|<br />
|<br />
|-<br />
| <br />
| Specification-Title<br />
|<br />
|<br />
|-<br />
| <br />
| Specification-Version<br />
|<br />
|<br />
|-<br />
| <br />
| Specification-Vendor<br />
|<br />
|<br />
|-<br />
| <br />
| Sealed<br />
|<br />
|<br />
|-<br />
| J2EE<br />
| Java-Bean<br />
| Definiert eine Java Bean Klasse<br />
|<br />
|-<br />
| <br />
| x-Digest-y<br />
|<br />
|<br />
|-<br />
| <br />
| Magic<br />
|<br />
|<br />
|-<br />
|}<br />
Jede Manifest-Datei muss mit einer Leerzeile abgeschlossen werden.<br />
<br />
==Beispiel einer Manifest-Datei==<br />
Manifest-Version: 1.0<br />
Created-By: Eagle Projekt Manager 1.1.0.0<br />
Permissions: all-permissions<br />
Codebase: *.eagleside.de<br />
Application-Name: DatabaseDesigner<br />
Main-Class: de.eagleside.databasedesigner.DatabaseDesignerMain<br />
CLASS-PATH: ./lib/jdom.jar ./lib/EagleSwingLibrary.jar ./lib/EagleUtilLibrary.jar<br />
[Leerzeile!]<br />
<br />
Es ist üblich, Abhängigkeiten in einem Unterverzeichnis relativ zur Programm-Jar-Datei abzulegen.<br />
Laufwerksangaben sind systemabhängig, daher sollte darauf verzichtet werden.<br />
<br />
=JAR-Datei erstellen=<br />
Um eine JAR-Datei aus einem fertig kompilierten Projekt auf einer Kommandozeile zu erstellen, ist prinzipiell folgender Befehl anzuwenden:<br />
jar cvfm MeinJar.jar manifest.txt input-file(s)<br />
Das ''input-file(s)'' ist eine Liste von einer oder mehreren Dateien, die die Jar-Datei enthalten soll. Mehrere Dateien werden mit einem Leerzeichen voneinander abgegrenzt. Mehrere Dateien gleichen Typs können mit einem Wildcard-Symbol (*) angegeben werden. Wenn ein zu speicherndes Element ein Verzeichnis ist, werden die Inhalte dieses Verzeichnisses rekursiv der Jar-Datei hinzugefügt.<br />
Einen Sonderfall stellt der Punkt am Ende einer solchen Anweisung dar. Der Punkt sagt aus, dass der Inhalt des Verzeichnisses, von dem aus aus der Jar-Befehl gestartet wurde ins Jar-Archiv eingefügt werden soll.<br />
jar cvfm MeinJar.jar manifest.txt .<br />
Der Befehl erzeigt eine Jar-Datei, die eine Manifest-Datei enthält, sowie alle Verzeichnisse und Dateien des Verzeichnisses, von dem heraus der Jar-Befehl gestartet wurde.<br />
<br />
Auch folgender Befehl zum Erzeugen einer Jar-Datei ist gültig:<br />
jar cvfm MeinJar.jar manifest.txt icons audio *.class Lizenz.txt<br />
Der Jar-Datei wird ein Manifest hinzugefügt. Außerdem wird es Verzeichnisse mit Icons und Audiodateien (icons, audio) enthalten, in denen die Programm-Icons und einige Sound-Dateien abgelegt wurden. Schließlich noch alle Class-Dateien und eine Lizenz-Datei.<br />
Die meisten verfügbares [[IDE]]s haben bereits Funktionen an Bord, die das komfortabel per Mausklick erledigen können.<br />
<br />
=JAR-Datei ausführen=<br />
Um die Programmausführung einer Java-Anwendung, die in einer einer JAR-Datei gespeichert ist, per Doppelklick zu starten ist es notwendig, dass die Dateiendung (.jar) mit dem Java-Interpreter verknüpft ist. Normalerweise ist das bei Windows-System der Fall. Bei Linux-Systemen muss da oft nachgeholfen werden.<br />
<br />
Tipp: Wie Sie vorgehen, wenn eine Jar-Datei nicht startet, erfahren Sie im Artikel [[Jar-Datei mit Doppelklick nicht ausführbar]].<br />
<br />
Neben dem Start per Mausklick, ist aber insbesondere der Start in der Befehlszeile wichtig, um [[Was ist eine Exception|Exceptions]], die während der Ausführung in die Java-Console geworfen werden, lesen zu können. Folgender Befehl startet die Ausführung einer Anwendung, die in einer JAR-Datei gespeichert ist:<br />
java -jar MeinJar.jar<br />
<br />
{{Fragen stellen}}<br />
<br />
=Quellen=<br />
*[https://docs.oracle.com/javase/8/docs/technotes/guides/jar/jar.html JAR File Specification]<br />
*[http://docs.oracle.com/javase/tutorial/deployment/jar/index.html Packaging Programs in JAR Files]<br />
<br />
=Links=<br />
*[https://java-blog-buch.bytes4fun.de/070404-jar-klassen-zusammenfassen-und-ausfuehren/ Java-Blog-Buch: Jar - Klassen zusammenfassen und ausführen]<br />
<br />
[[Kategorie:Java]]<br />
[[Kategorie:Java Grundlagen]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=Gleitkommazahlen_mit_Java_runden&diff=9547Gleitkommazahlen mit Java runden2026-07-01T14:35:59Z<p>L-ectron-x: </p>
<hr />
<div>In unserem [https://www.java-blog-buch.de/11-02-mathematisches-mit-java-lang-math/ Artikel über die Klasse java.lang.Math] haben wir auf unserer eLerning-Plattform [https://java-blog-buch.bytes4fun.de/ Java-Blog-Buch] bereits einige Dinge zum Thema Runden mit Java besprochen. Mit einigen Code-Beispielen möchten wir hier noch einmal abrunden.<br />
<br />
=Cast=<br />
Eine einfache und ungenaue Methode zu runden ist, der Gleitkommazahl die Nachkommastellen einfach abzuschneiden. Beim Casten wird also immer abgerundet. In einigen Fällen kann das genügen, in den meisten jedoch nicht.<br />
<syntaxhighlight lang="java"><br />
/**<br />
* Schneidet Nachkommastellen einer Gleitkommazahl ab.<br />
*<br />
* @param value ist der Gleitkommazahlenwert, dem die Nachkommastellen abgeschnitten werden sollen<br />
*/<br />
private int cutOffDecimalPlaces(double value) {<br />
return (int) value;<br />
}<br />
</syntaxhighlight><br />
Nach Übergabe der Zahl 1234.565 erhalten wir 1234 als Rückgbewert.<br />
<br />
=Math.round()=<br />
Die Klasse {{JAPI|java.lang.Math}} bietet eine [[Methode]] zum ([https://de.wikipedia.org/wiki/Rundung#Kaufm%C3%A4nnisches_Runden kaufmännischem]) Runden von Gleitkommazahlen an. Mit dieser können wir recht einfach eine eigene Methode schreiben, die uns Dezimalzahlen auf eine beliebige Anzahl Nachkommastellen rundet.<br />
<syntaxhighlight lang="java"><br />
/**<br />
* Rundet den übergebenen Wert auf die Anzahl der übergebenen Nachkommastellen<br />
*<br />
* @param value ist der zu rundende Wert.<br />
* @param decimalPoints ist die Anzahl der Nachkommastellen, auf die gerundet werden soll.<br />
*/<br />
private double round(double value, int decimalPoints) {<br />
double d = Math.pow(10, decimalPoints);<br />
return Math.round(value * d) / d;<br />
}<br />
</syntaxhighlight><br />
<br />
Der Aufruf der Methode in einer [[Klasse]] zum Runden einer Zahl auf zwei Nachkommastellen sieht dann z.B. so aus:<br />
<syntaxhighlight lang="java"><br />
System.out.println(round(1234.565, 2);<br />
</syntaxhighlight><br />
<br />
=Math.rint()=<br />
Die Methode rint() rundet double-Werte mathematisch.<br />
<syntaxhighlight lang="java"><br />
/**<br />
* Rundet den übergebenen Wert auf die Anzahl der übergebenen Nachkommastellen<br />
*<br />
* @param value ist der zu rundende Wert.<br />
* @param decimalPoints ist die Anzahl der Nachkommastellen, auf die mathematisch gerundet werden soll.<br />
*/<br />
private double rint(double value, int decimalPoints) {<br />
double d = Math.pow(10, decimalPoints);<br />
return Math.rint(value * d) / d;<br />
}<br />
</syntaxhighlight><br />
<br />
=Math.floor()=<br />
Die Methode floor() rundet auf die nächst kleinere Zahl.<br />
<br />
=Math.ceil()=<br />
Die Methode ceil() rundet auf die nächst größere Zahl.<br />
<br />
=String#format()=<br />
In Programmen müssen Ergebnisse von Berechnungen oft für eine Ausgabe passend formatiert werden. Dazu gehört auch '''das Runden, bspw. von Euro-Beträgen'''.<br />
<br />
<syntaxhighlight lang="java"><br />
import java.util.Locale;<br />
<br />
public class Formatter {<br />
public static void main(String[] args) {<br />
double number = 1234.565;<br />
System.out.println(number+" gerundet: "+String.format("%1.2f €", number));<br />
}<br />
}<br />
</syntaxhighlight><br />
Möchte man bspw. das englische oder französische Zahlenformat ausgeben, muss noch ein passendes {{JAPI|Locale}} als erster Parameter der format()-[[Methode]] übergeben werden.<br />
String.format(Locale.FRENCH, "%1.2f", number)<br />
Ansonsten wird das von der [[JRE]] erkannte Locale des [[Betriebssystem|Betriebssystems]] verwendet.<br />
<br />
=NumberFormat=<br />
Auch relativ einfach ist das Runden von Dezimalzahlen mit [[NumberFormat]].<br />
<br />
<syntaxhighlight lang="java"><br />
import java.text.NumberFormat;<br />
<br />
public class Formatter {<br />
public static void main(String[] args) {<br />
double number = 1234.565;<br />
NumberFormat formatter = NumberFormat.getInstance();<br />
formatter.setMaximumFractionDigits(2);<br />
System.out.println(number+" gerundet: "+formatter.format(number));<br />
}<br />
}<br />
</syntaxhighlight> <br />
<br />
Mit Hilfe der Methode <code>NumberFormat#setMaximumFractionDigits(int value)</code> auf eine festgelegte Anzahl an Nachkommastellen begrenzen. Dabei wird auch eine Rundung der Zahl vorgenommen.<br />
Möchte man bspw. das englische oder französische Zahlenformat ausgeben, muss noch ein passendes {{JAPI|Locale}} als Parameter der <code>getInstance()</code>-[[Methode]] übergeben werden.<br />
NumberFormat formatter = NumberFormat.getInstance(Locale.FRENCH);<br />
Ansonsten wird das von der [[JRE]] erkannte Locale des [[Betriebssystem|Betriebssystems]] verwendet.<br />
<br />
=DecimalFormat=<br />
Noch eine einfache Variante für das Runden von Gleitkommazahlen mit Java - mit [[DecimalFormat]].<br />
<br />
{{JAPI|DecimalFormat}} ist eine Subklasse von NumberFormat für die Formatierung von Dezimalzahlen. Als Unterklasse von NumberFormat stehen auch hier Formatierungen von Dezimalzahlen in Abhängigkeit des Gebietsschemas zur Verfügung.<br />
<br />
<syntaxhighlight lang="java"><br />
import java.text.DecimalFormat;<br />
<br />
public class Formatter {<br />
public static void main(String[] args) {<br />
double number = 1234.565;<br />
DecimalFormat formatter = new DecimalFormat("#.##");<br />
System.out.println(number+" gerundet: "+formatter.format(number));<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
DecimalFormat unterstützt verschiedene lokalisierbare Zahlen-Typen, so auch Ganzzahlen (123), Festkommazahlen (123,4), wissenschaftliche Notation (1,23E4), Prozentangaben (12%) und Währungsbeträge (123 $).<br />
<br />
{{Fragen stellen}}<br />
<br />
=Siehe auch=<br />
*{{JAPI|NumberFormat}}<br />
*{{JAPI|DecimalFormat}}<br />
*[[String]]<br />
*{{JAPI|String}}<br />
<br />
[[Kategorie:Java-Codeschnipsel]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=Byte-Welt&diff=9546Byte-Welt2026-07-01T14:35:24Z<p>L-ectron-x: /* Entstehung */</p>
<hr />
<div>'''Byte-Welt''' ging aus einem älteren Projekt hervor, das von einigen jungen Programmierern 2004 nach wachsender Unzufriedenheit mit ihrem Lieblings-Java-Forum entstand. Damals hieß das Projekt noch '''Coding Community''' und beschäftigte sich hauptsächlich mit der Programmierung in Java. Auch ein kleines Forum und einen Entwickler-Chat gab es damals schon, beide aber wenig besucht. Einige Programmierer-Freunde verließen das Projekt, die Community schrumpfte. Im Juni 2006 wurde von [[Benutzer:EagleEye|EagleEye]] und einer Hand voll Programmierer-Freunde ein Neuanfang vereinbart. Der etwas sperrige Name wurde verworfen und Byte-Welt wurde gegründet.<br />
<br />
==Entstehung==<br />
Bei Problemen im Programmieralltag holte man sich zu deren Lösung Ideen und Anregungen aus Internet-Foren, Wikis, Chats etc. - heute häufig auch von KI-Assistenten. Die meisten Programmierer beherrschen mehrere Programmiersprachen, um ihre tägliche Arbeit bewältigen zu können und melden sich daher bei mehreren spezialisierten Communities an, die sich mit jeweils einer Programmiersprache beschäftigen.<br />
<br />
Die Idee war daher, ein Projekt zu schaffen, in dem sich Programmierer der wichtigsten Programmiersprachen unter einem Dach und mit nur einem Benutzerkonto über verschiedenste Web-Dienste austauschen können. Dieses Wiki ist demnach nur ein Teil von ''byte-welt.net''.<br />
<br />
Byte-Welt selbst versammelte IT-Experten vieler Fachrichtungen, und konnte so ein breites Spektrum abdecken. Die bis dato aktive Community bestand aus Schülern, Studenten, Fachinformatikern und Diplom-Ingenieuren. Viele Hobby-Entwickler fanden auch den Weg zu uns.<br />
<br />
Heute ist Byte-Welt zum großen Teil ein Archiv für IT-Wissen und damit ein Teil deutscher IT-Geschichte.<br />
<br />
<br />
<br />
==Inhalte==<br />
''byte-welt.net'' bestand aus einem Forum (einem heute noch aktiven Entwickler- [https://discordapp.com/invite/S4P8RAD Chat], diesem [http://wiki.byte-welt.de Wiki], der nicht mehr aktiven Java Link Base und mehreren weiteren Projekten wie bspw. das heute noch verfügbare [https://java-blog-buch.bytes4fun.de/ Java Blog Buch].<br />
<br />
<br />
{{Byte-Welt}}<br />
<br />
<br />
==Weblinks==<br />
*[http://www.byte-welt.net Byte-Welt-Forum]<br />
*[[Byte-Welt_Wiki:Impressum|Impressum]]<br />
<br />
[[Kategorie:Byte-Welt]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=B%C3%BCcher_und_Tutorials_(Java)&diff=9545Bücher und Tutorials (Java)2026-07-01T14:27:47Z<p>L-ectron-x: /* eBooks */</p>
<hr />
<div>Liste von Büchern und Tutorials über die Programmiersprache [[Java]]. Diskussionen über Bücher und Tutorials können im entsprechenden [http://forum.coding-community.net/showthread.php5?t=66 Thread des Forums] geführt werden.<br />
<br />
==Bücher==<br />
*[http://www.amazon.de/gp/product/382726281X/ Java in 21 Tagen] von Laura Lemay<br />
*[http://www.kickjava.com/books/java.htm Free Computer Books] Riesiges Sortiment an Büchern über Java.<br />
*[http://www.amazon.de/dp/3897214482/ Java von Kopf bis Fuß] Ein Bestseller!<br />
*[http://www.amazon.de/Java-als-erste-Programmiersprache-Einsteiger/dp/3834806560 Java als erste Programmiersprache: Vom Einsteiger zum Profi] von Cornelia Heinisch, Frank Müller-Hofmann, Joachim Goll<br />
*[http://www.amazon.de/gp/product/3897214210/ Entwurfsmuster von Kopf bis Fuß] von Eric Freeman, Elisabeth Freeman, Kathy Sierra, Bert Bates<br />
*[http://www.amazon.de/Einführung-Java-BlueJ-Objektorientierte-Programmierung/dp/3836216302/ Einführung in Java mit BlueJ: Objektorientierte Programmierung für Einsteiger] von Florian Siebler<br />
<br />
==eBooks==<br />
*[http://www.javabuch.de/ Das Javabuch]<br />
*[http://openbook.galileocomputing.de/javainsel/ Java ist auch eine Insel] von Christian Ullenboom<br />
*[https://java-blog-buch.bytes4fun.de/ Java Blog Buch] Ein Java-Buch in Blog-Form<br />
*[http://www.programmierkurs-java.de/ Programmierkurs Java] von Dr.-Ing. Dietrich Boles<br />
*[http://www.gailer-net.de/tutorials/java/index.html Java Tutorial interaktiv — Programmieren lernen mit Java] von Bradley Kjell (übersetzt von Heinrich Gailer)<br />
<br />
==Video Tutorials==<br />
*[http://www.javavideokurs.de/ Der Java Video Kurs: Dein Weg zum Java-Profi!] von Thomas Klutsch<br />
*[https://www.video2brain.com/de/search.htm?search_entry=java Video2Brain - Java-Themen Übersicht] (Interaktive Schulungs DVD-ROMs)<br />
<br />
==Größere Tutorials==<br />
Allgemein:<br />
*[http://wiki.byte-welt.net/mediawiki/download/Ein%20kleines%20Zeichnungsprogramm.zip Ein kleines Zeichenprogramm] (inkl. Beispielprogramm) von Benjamin Sigg und Janni Kovacs<br />
*[http://www.java2s.com/ Java2S] (zahlreiche Beispiele)<br />
<br />
Swing:<br />
*[https://docs.oracle.com/javase/tutorial/uiswing/index.html Creating a GUI With JFC/Swing] Größtes Swing-Tutorial von Oracle.<br />
*[http://www.codeguru.com/java/Swing/ Java CodeGuru:Swing] Modifikation von GUI-Elementen<br />
<br />
==Kleinere Tutorials==<br />
*[http://www.coreservlets.com/Apache-Tomcat-Tutorial/tomcat-7-with-eclipse.html Tutorial: Installing Tomcat 7 and Using it with Eclipse] auf [http://www.coreservlets.com coreservlets.com]<br />
<br />
==Nachschlagewerke==<br />
<br />
*[http://javaalmanac.com/egs/index.html Das grosse Java-Almanac]<br />
*[http://www.koders.com/ Source Code Search Engine] Wer Code sucht, der wird hier fündig.<br />
<br />
==Code-Beispiele==<br />
*[http://www.java-only.com/ Java-Only | Tutorials for Java]<br />
*[http://jexamples.com/ Java Examples - JExamples]<br />
*[http://www.java2s.com/ Programming tutorials and source code examples]<br />
*[http://www-st.inf.tu-dresden.de/SalesPoint/v3.1/faq/SwingExamples/index.html Swing Examples]<br />
<br />
[[Kategorie:Java]]<br />
[[Kategorie:Tutorials (Java)]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=Vorlage:Fragen_stellen&diff=9544Vorlage:Fragen stellen2026-07-01T14:27:18Z<p>L-ectron-x: /* Fragen */</p>
<hr />
<div><br />
=Fragen=<br />
Das Thema wurde nicht ausreichend behandelt? Du hast Fragen dazu und brauchst weitere Informationen? Lass Dir von uns helfen!<br />
<br />
*Besuche unseren [https://discordapp.com/invite/S4P8RAD Chat]<br />
<br />
Wir helfen dir gerne!<br />
<br />
<noinclude><br />
<br />
Zur Verwendung in deinem Artikel, kopierst du folgenden Text und fügst ihn in deinen Artikel ein:<br />
<syntaxhighlight lang="text">{{Fragen stellen}}</syntaxhighlight><br />
[[Kategorie:Vorlagen]]</noinclude></div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=Programmier_Blogs&diff=9543Programmier Blogs2026-07-01T14:25:58Z<p>L-ectron-x: /* Java */</p>
<hr />
<div>Blogs rund um das Thema der Programmierung<br />
<br />
==Java==<br />
*[https://java-blog-buch.bytes4fun.de/ Java Blog Buch]<br />
*[http://www.kurungkurawal.com/ {Kurung Kurawall}]<br />
*[http://www.informit.com/articles/ Informit Articles]<br />
<br />
[[Kategorie:Programmierung]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=Hauptseite&diff=9542Hauptseite2026-07-01T14:21:10Z<p>L-ectron-x: </p>
<hr />
<div>{{Byte-Welt}}<br />
<!-- Willkommen --><br />
<center><table cellpadding="0px" cellspacing="0px" style="margin-bottom:2em;"><br />
<tr><br />
<td align="center" style="border:1px solid #2C4051; padding:0.75em; font-weight:bold; color:white; background-color:#2C4051"><h2>Willkommen im Byte-Welt-Wiki</h2></td><br />
</tr><br />
<tr><br />
<td valign="top" style="border:1px solid #2C4051; width:100%; border-top:0px; padding:0.75em; text-align:left"><h3>Was das Byte-Welt-Wiki heute ist</h3><br />
Das Byte-Welt-Wiki ist ein Archiv und Lernprojekt im Themenbereich Hardware und Programmierung. Viele Inhalte, wie Best Practice, Codestücke oder Tutorials stammen aus der aktiven Zeit der Byte‑Welt‑Community, die über Jahre ein Forum, einen Chat, dieses Wiki und das Java-Blog-Buch betrieb. Zahlreiche Beiträge wurden damals gemeinschaftlich erstellt und gepflegt – ein Stück deutschsprachiger IT‑Geschichte, die hier bewusst erhalten bleibt.<br />
<h3>Wie das Projekt weitergeführt wird</h3><br />
Das Byte-Welt-Wiki wird schrittweise modernisiert. Die Weiterentwicklung erfolgt bewusst langsam und ohne Zeitdruck. Monat für Monat kommen neue Themen hinzu oder bestehende Inhalte werden ergänzt.<br />
</td><br />
</tr><br />
</table></center><br />
<br />
<!-- Autor des Monats --><!-- Tipp --><!-- Newsflash --><br />
<table cellpadding="0px" cellspacing="0px" style="margin-bottom:2em;"><br />
<tr><br />
<!--<td align="center" style="border:1px solid #2C4051; padding:0.75em; font-weight:bold; background-color:#2C4051">Autor/-in des Monats</td><br />
<td></td>--><br />
<td align="center" style="border:1px solid #2C4051; padding:0.75em; font-weight:bold; color:white; background-color:#2C4051">Tipp</td><br />
<td></td><br />
<td align="center" style="border:1px solid #2C4051; padding:0.75em; font-weight:bold; color:white; background-color:#2C4051">Newsflash</td><br />
</tr><br />
<tr><br />
<!--<td style="border-left:1px solid #2C4051; border-right:1px solid #2C4051; width:30%; text-align:left"><table><tr><td>[[Bild: Pokal.png]]</td><td><br/>'''I'''n diesem Monat wurden folgende Autoren für gute Arbeit im Wiki ausgezeichnet:</td></tr></table></td><br />
<td></td>--><br />
<td style="border-left:1px solid #000; border-right:1px solid #000; width:30%; text-align:left"><table><tr><td>[[Bild: Gluehbirne.png]]</td><td><br/> '''F'''ür das schnelle Navigieren im Wiki bitte das [[Inhalt|Inhaltsverzeichnis]] nutzen.</td></tr></table></td><br />
<td></td><br />
<td style="border-left:1px solid #000; border-right:1px solid #000; width:30%; text-align:left"><table><tr><td>[[Bild: Newsflash.png]]</td><td>'''News aus dem Byte-Welt Themenbereich'''</td></tr></table></td><br />
<tr><br />
<td valign="top" style="border:1px solid #2C4051; width:30%; border-top:0px; padding:10px"><br />
<table align="center" style="margin-top:20px"><br />
<tr><br />
<td>{{Neuer Artikel}}</td><br />
</tr><br />
</table><br />
</td><br />
<td style="width:5%"></td><br />
<td valign="top" style="border:1px solid #2C4051; width:30%; border-top:0px; padding:10px"><br />
<strong>Zum Jahresanfang stellte Byte-Welt den Forum-Betrieb ein!</strong><br />
Apache NetBenas 30 erschienen<br />
Eclipse 2026-06 erschienen<br />
Oracle veröffentlicht Java 26 und das Update für Java SE 8 Update 491<br />
</td><br />
</tr><br />
</table><br />
<br />
<!-- Zufallsartikeln Nr1 + 2 --><br />
<table cellpadding="0px" cellspacing="0px"><br />
<tr><br />
<td align="center" style="border:1px solid #2C4051; padding:0.75em; font-weight:bold; color:white; background-color:#2C4051">Kategorien</td><br />
</tr><br />
<tr><br />
<td valign="top" style="border:1px solid #2C4051; width:48%; border-top:0px; padding:10px"><br />
<tagcloud><br />
min_count=5<br />
</tagcloud><br />
</td><br />
</tr><br />
</table></div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=Hauptseite&diff=9541Hauptseite2026-07-01T14:11:04Z<p>L-ectron-x: </p>
<hr />
<div>{{Byte-Welt}}<br />
<!-- Willkommen --><br />
<center><table cellpadding="0px" cellspacing="0px" style="margin-bottom:2em;"><br />
<tr><br />
<td align="center" style="border:1px solid #2C4051; padding:0.75em; font-weight:bold; color:white; background-color:#2C4051">Willkommen im Byte-Welt-Wiki</td><br />
</tr><br />
<tr><br />
<td valign="top" style="border:1px solid #2C4051; width:100%; border-top:0px; padding:0.75em; text-align:left">Das Byte-Welt-Wiki ist ein Archiv und Lernprojekt im Themenbereich Hardware und Programmierung. Viele Inhalte stammen aus der aktiven Zeit der Byte‑Welt‑Community, die über Jahre ein Forum, einen Chat, dieses Wiki und das Java-Blog-Buch betrieb. Zahlreiche Beiträge wurden damals gemeinschaftlich erstellt und gepflegt – ein Stück deutschsprachiger IT‑Geschichte, die hier bewusst erhalten bleibt.<br />
</td><br />
</tr><br />
</table></center><br />
<br />
<!-- Autor des Monats --><!-- Tipp --><!-- Newsflash --><br />
<table cellpadding="0px" cellspacing="0px" style="margin-bottom:2em;"><br />
<tr><br />
<!--<td align="center" style="border:1px solid #2C4051; padding:0.75em; font-weight:bold; background-color:#2C4051">Autor/-in des Monats</td><br />
<td></td>--><br />
<td align="center" style="border:1px solid #2C4051; padding:0.75em; font-weight:bold; color:white; background-color:#2C4051">Tipp</td><br />
<td></td><br />
<td align="center" style="border:1px solid #2C4051; padding:0.75em; font-weight:bold; color:white; background-color:#2C4051">Newsflash</td><br />
</tr><br />
<tr><br />
<!--<td style="border-left:1px solid #2C4051; border-right:1px solid #2C4051; width:30%; text-align:left"><table><tr><td>[[Bild: Pokal.png]]</td><td><br/>'''I'''n diesem Monat wurden folgende Autoren für gute Arbeit im Wiki ausgezeichnet:</td></tr></table></td><br />
<td></td>--><br />
<td style="border-left:1px solid #000; border-right:1px solid #000; width:30%; text-align:left"><table><tr><td>[[Bild: Gluehbirne.png]]</td><td><br/> '''F'''ür das schnelle Navigieren im Wiki bitte das [[Inhalt|Inhaltsverzeichnis]] nutzen.</td></tr></table></td><br />
<td></td><br />
<td style="border-left:1px solid #000; border-right:1px solid #000; width:30%; text-align:left"><table><tr><td>[[Bild: Newsflash.png]]</td><td>'''News aus dem Byte-Welt Themenbereich'''</td></tr></table></td><br />
<tr><br />
<td valign="top" style="border:1px solid #2C4051; width:30%; border-top:0px; padding:10px"><br />
<table align="center" style="margin-top:20px"><br />
<tr><br />
<td>{{Neuer Artikel}}</td><br />
</tr><br />
</table><br />
</td><br />
<td style="width:5%"></td><br />
<td valign="top" style="border:1px solid #2C4051; width:30%; border-top:0px; padding:10px"><br />
<strong>Zum Jahresanfang stellte Byte-Welt den Forum-Betrieb ein!</strong><br />
Apache NetBenas 30 erschienen<br />
Eclipse 2026-06 erschienen<br />
Oracle veröffentlicht Java 26 und das Update für Java SE 8 Update 491<br />
</td><br />
</tr><br />
</table><br />
<br />
<!-- Zufallsartikeln Nr1 + 2 --><br />
<table cellpadding="0px" cellspacing="0px"><br />
<tr><br />
<td align="center" style="border:1px solid #2C4051; padding:0.75em; font-weight:bold; color:white; background-color:#2C4051">Kategorien</td><br />
</tr><br />
<tr><br />
<td valign="top" style="border:1px solid #2C4051; width:48%; border-top:0px; padding:10px"><br />
<tagcloud><br />
min_count=5<br />
</tagcloud><br />
</td><br />
</tr><br />
</table></div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=Hauptseite&diff=9540Hauptseite2026-07-01T13:51:45Z<p>L-ectron-x: </p>
<hr />
<div>{{Byte-Welt}}<br />
<!-- Willkommen --><br />
<center><table cellpadding="0px" cellspacing="0px" style="margin-bottom:2em;"><br />
<tr><br />
<td align="center" style="border:1px solid #2C4051; padding:0.75em; font-weight:bold; color:white; background-color:#2C4051">Willkommen im Byte-Welt-Wiki</td><br />
</tr><br />
<tr><br />
<td valign="top" style="border:1px solid #2C4051; width:100%; border-top:0px; padding:0.75em; text-align:left">Das Byte-Welt-Wiki ist ein Archiv und Lernprojekt im Themenbereich Hardware und Programmierung. Viele Inhalte stammen aus der aktiven Zeit der Byte‑Welt‑Community, die über Jahre ein Forum, einen Chat, dieses Wiki und das Java-Blog-Buch betrieb. Zahlreiche Beiträge wurden damals gemeinschaftlich erstellt und gepflegt – ein Stück deutschsprachiger IT‑Geschichte, die hier bewusst erhalten bleibt.<br />
</td><br />
</tr><br />
</table></center><br />
<br />
<!-- Autor des Monats --><!-- Tipp --><!-- Newsflash --><br />
<table cellpadding="0px" cellspacing="0px" style="margin-bottom:2em;"><br />
<tr><br />
<!--<td align="center" style="border:1px solid #2C4051; padding:0.75em; font-weight:bold; background-color:#2C4051">Autor/-in des Monats</td><br />
<td></td>--><br />
<td align="center" style="border:1px solid #2C4051; padding:0.75em; font-weight:bold; color:white; background-color:#2C4051">Tipp</td><br />
<td></td><br />
<td align="center" style="border:1px solid #2C4051; padding:0.75em; font-weight:bold; color:white; background-color:#2C4051">Newsflash</td><br />
</tr><br />
<tr><br />
<!--<td style="border-left:1px solid #2C4051; border-right:1px solid #2C4051; width:30%; text-align:left"><table><tr><td>[[Bild: Pokal.png]]</td><td><br/>'''I'''n diesem Monat wurden folgende Autoren für gute Arbeit im Wiki ausgezeichnet:</td></tr></table></td><br />
<td></td>--><br />
<td style="border-left:1px solid #000; border-right:1px solid #000; width:30%; text-align:left"><table><tr><td>[[Bild: Gluehbirne.png]]</td><td><br/> '''F'''ür das schnelle Navigieren im Wiki bitte das [[Inhalt|Inhaltsverzeichnis]] nutzen.</td></tr></table></td><br />
<td></td><br />
<td style="border-left:1px solid #000; border-right:1px solid #000; width:30%; text-align:left"><table><tr><td>[[Bild: Newsflash.png]]</td><td>'''News aus dem Byte-Welt Themenbereich'''</td></tr></table></td><br />
<tr><br />
<!--<td valign="top" style="border:1px solid #000; width:30%; border-top:0px; padding:5px"><br/><br/>[[Benutzer:AndreUhres|AndreUhres]], [[Benutzer:SeannWilliamScott|SeannWilliamScott]]<br/>mehr dazu [[Auszeichnungen| hier..]]<br />
</td><br />
<td style="width:5%"></td>--><br />
<td valign="top" style="border:1px solid #2C4051; width:30%; border-top:0px; padding:10px"><br />
<table align="center" style="margin-top:20px"><br />
<tr><br />
<td>{{Neuer Artikel}}</td><br />
</tr><br />
</table><br />
</td><br />
<td style="width:5%"></td><br />
<td valign="top" style="border:1px solid #2C4051; width:30%; border-top:0px; padding:10px"><br />
<strong>Zum Jahresanfang stellte Byte-Welt den Forum-Betrieb ein!</strong><br />
Apache NetBenas 26 erschienen [https://netbeans.apache.org/front/main/download/nb26/]<br />
Eclipse 2026-06 erschienen [https://www.heise.de/news/Eclipse-IDE-2025-06-verbessert-das-Schreiben-und-Debuggen-von-Java-Code-10443131.html]<br />
Oracle veröffentlicht Java 26 und das Update für Java SE 8 Update 491<br />
</td><br />
</tr><br />
</table><br />
<br />
<!-- Zufallsartikeln Nr1 + 2 --><br />
<table cellpadding="0px" cellspacing="0px"><br />
<tr><br />
<td align="center" style="border:1px solid #2C4051; padding:0.75em; font-weight:bold; color:white; background-color:#2C4051">Kategorien</td><br />
</tr><br />
<tr><br />
<td valign="top" style="border:1px solid #2C4051; width:48%; border-top:0px; padding:10px"><br />
<tagcloud><br />
min_count=5<br />
</tagcloud><br />
</td><br />
</tr><br />
</table></div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=Vorlage:Byte-Welt&diff=9539Vorlage:Byte-Welt2026-07-01T13:40:47Z<p>L-ectron-x: </p>
<hr />
<div><div style="font-size: 1.5em;"><br />
{| width="100%"<br />
! width="33%" |[https://discordapp.com/invite/S4P8RAD Byte-Welt-Chat]<br />
! width="33%" |[https://java-blog-buch.bytes4fun.de/ Java-Blog-Buch]<br />
! width="33%" |[https://wiki.byte-welt.net Byte-Welt-Wiki]<br />
<!-- width="22%" |[http://www.javalinkbase.de/ JavaLinkBase.de] --><br />
|}<br />
</div><br />
<br />
<noinclude>[[Kategorie:Vorlagen]]</noinclude></div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=Jar-Datei_mit_Doppelklick_nicht_ausf%C3%BChrbar%3F&diff=7596Jar-Datei mit Doppelklick nicht ausführbar?2018-02-28T15:11:06Z<p>L-ectron-x: /* Links */</p>
<hr />
<div>Jar-Dateien ('''J'''ava '''Ar'''chive) sind prinzipiell im Zip-Format komprimierte Dateien, die aber durch spezielle Inhalte erweitert wurden. Per Doppelklick können von der [[JVM]] die in ihnen verpackten Java-Anwendungen ausgeführt werden.<br />
<br />
Du hast eine [[JAR-Datei]] erzeugt oder erhalten und diese lässt sich nicht per Doppelklick starten? Lösungen zu diesem Problem werden wir im Folgenden besprechen.<br />
<br />
=Anwendung oder Bibliothek?=<br />
Jar-Dateien fassen in sich geschlossene Anwendungen oder Bibliotheken (Library) zusammen. Während Bibliotheken nicht ausführbar sind und dazu dienen Funktionalität für ein Programm bereit zu stellen, sind Anwendungen, die in Jar-Dateien gespeichert sind durchaus per Doppelklick ausführbar. <br />
<br />
Ist die Jar-Datei nicht per Doppelklick ausführbar, liegt möglicherweise eine Bibliothek vor. Um das zu prüfen, sieht man sich kurzerhand den Inhalt der Jar-Datei mit einem Packprogramm an.<br />
<br />
'''Grundsätzlich müssen wir uns zu aller erst folgende Frage stellen:'''<br />
'''Ist es nur diese Jar-Datei, die ich nicht starten kann, oder sind alle Jar-Dateien betroffen?'''<br />
<br />
=Problem mit einer bestimmten Jar-Datei=<br />
<br />
==Jar-Datei in der Eingabeaufforderung/Terminal starten==<br />
Um zu testen, ob eine Jar-Datei zumindest fehlerfrei auf der Kommandozeile starten kann, wird folgender Befehl eingegeben:<br />
java -jar MeinJar.jar<br />
''MeinJar.jar'' bezeichnet dabei die auszuführende Jar-Datei. Zum Aufruf muss man sich bereits in dem Verzeichnis befinden, in welchem die Jar-Datei gespeichert wurde.<br />
<br />
Sollte es ein Problem mit der Jar-Datei geben, das die Ausführung verhindert, wird eine Fehlermeldung auf der Console/Eingabeaufforderung/Terminal ausgegeben.<br />
'''Der erste Schritt bei Problemen mit Jar-Dateien sollte also immer sein, zu sehen, ob bei der Ausführung Fehler auf der Console ausgegeben werden.'''<br />
<br />
==Aufbau und Inhalt von META-INF==<br />
Damit eine Jar-Datei ausführbar wird, enthält sie, wie bereits oben beschrieben, weitere spezielle Inhalte, die von der JVM ausgelesen und verarbeitet werden können. Im Wesentlichen handelt es sich dabei um das Verzeichnis ''META-INF'' bzw. um seinen Inhalt. In diesem Verzeichnis muss die [https://wiki.byte-welt.net/wiki/JAR-Datei#MANIFEST.MF Manifest-Datei] enthalten sein. Das Verzeichnis META-INF selbst liegt im Wurzelverzeichnis der Jar-Datei.<br />
<br />
[/]<br />
|__[META-INF]<br />
| |__ MANIFEST.MF<br />
|<br />
|__[mypackage]<br />
|__ Main.class<br />
<br />
Die Manifest-Datei enthält eine Reihe von Informationen, die der Interpreter für die Ausführung einer Java-Anwendung benötigt.<br />
<br />
In der Manifest-Datei müssen, damit eine Java-Anwendung per Jar-Datei ausführbar wird, mindestens folgende Angaben enthalten sein:<br />
<br />
Manifest-Version: 1.0<br />
Main-Class: mypackage.Main<br />
<Leerzeile><br />
<br />
Hinter Main-Class verbirgt sich die [[Klasse]], die die main()-[[Methode]] enthält und damit die Anwendung starten kann. Die Klasse heißt ''Main.class'' und liegt in diesem (obigen) Beispiel im [[Package]] ''mypackage''.<br />
'''Wichtig:''' Ohne eine Leerzeile am Ende der Manifest-Datei wird die Jar-Datei nicht per Mausklick ausführbar sein!<br />
Dieser Fehler tritt oft nur auf, wenn man die Jar-Datei manuell in der Eingabeaufforderung/Terminal erzeugt hat und die Leerzeile vergessen wurde. Eigentlich alle großen Java-[[IDE|IDEs]] können ausführbare Jar-Dateien erzeugen und werden diesen Part richtig machen.<br />
<br />
Wenn wir externe Bibliotheken, wie bspw. einen Datenbanktreiber oder ein [[LookAndFeel]] in unserem Programm benutzen, müssen diese entsprechend im Manifest unserer Jar-Datei eingebunden sein.<br />
<br />
Class-Path: ./db/database.jar ./laf/look-and-feel.jar<br />
<br />
Daher müsste die Zeile '''Class-Path:''' in der Manifest-Datei enthalten sein. In unserem Beispiel sind die eingebundenen Bibliotheken in verschiedenen Verzeichnissen relativ zu unserer Jar-Datei abgelegt.<br><br />
Der Datenbanktreiber liegt, ausgehend vom Verzeichnis unserer Jar-Datei, eine Verzeichnisebene tiefer, im Verzeichnis ''db''. Die Bibliothek des eingesetzten LookAndFeel liegt, ausgehend vom Verzeichnis unserer Jar-Datei, eine Verzeichnisebene tiefer, im Verzeichnis ''laf''.<br />
<br />
Wenn die Bibliotheken für den Java-[[Interpreter]] nicht in den in unserer Manifest-Datei bezeichneten Verzeichnissen zu finden sind, wird ein Fehler auf der Console ausgegeben werden und unsere Jar-Datei ist möglicherweise nicht ausführbar.<br />
<br />
=Generelles Problem mit Jar-Dateien=<br />
Es gibt in allen Betriebssystemen Konstellationen, die verhindern, dass eine Jar-Datei nach einem (Doppel-)Klick mit der Maus auf das Dateisymbol startet.<br />
<br />
*Ist eine aktuelle JRE installiert? Ältere JREs starten Code von neueren Compilern nicht.<br />
<br />
Bei vielen Linux-Distributionen ist bspw. die Jar-Datei mit einem Archivierungsprogramm verknüpft, so dass der Inhalt der Jar-Datei angezeigt wird, statt dass sie gestartet wird.<br />
==Verknüpfung mit dem Java-Interpreter==<br />
Bei Einsatz bestimmter Komprimierungs- bzw. Archivierungsprogramme, wie bspw. [http://www.winrar.de/ WinRar] oder [http://www.7-zip.org/ 7Zip], kommt es gelegentlich aufgrund falscher Programmeinstellungen vor, dass diese Programme statt der gewünschten Jar-Datei beim Doppelklick auf eine Jar-Datei gestartet werden. Statt die Jar-Datei der JVM zu überlassen, leitet das [[Betriebssystem]] den Aufruf an das Packprogramm weiter, welches nun den Inhalt der Jar-Datei anzeigt.<br><br />
In den Einstellungen der Programme sollte nun zur Fehlerbehebung der Haken zum Öffnen von Jar-Dateien entfernt werden.<br />
<br />
Wenn man die Systemeinstellungen seines Linux-Systems nicht ändern möchte, kann man einen [[Programmstarter für Java-Programme anlegen]]. Der Doppelklick auf das angelegte Symbol startet dann das Java-Programm.<br />
<br />
===Interpreter-Typen===<br />
Es gibt zwei verschiedene Java-Interpreter. Zumindest unter [[Windows]]. Unter [[Linux]] gibt es nur einen [[JRE|Interpreter]], dem einerseits in der [[Kommandozeile]] auszuführende Java-Programme übergeben werden können. Andererseits kann man in Linux auch Einstellungen im System festmachen, die dann eine [[JAR-Datei|Jar-Datei]] mit Doppelklick, ohne Console starten können.<br />
<br />
Unter Windows wurden den Interpretern 2 Einsatzzwecke zugedacht. Will man ein Java-Programm auf der Kommandozeile starten, wird <code>java.exe</code> eingesetzt. Dieser Interpreter erzeugt Ausgaben auf der Java-Console bzw. auf der Kommandozeile, so dass bspw. [[Exception (Java)|Java-Fehlermeldungen]] oder Textausgaben, die im Programm mit <code>System.out.println()</code> erzeugt wurden, auf der Kommandozeile landen.<br />
<br />
Wenn man Java-Programme starten möchte, die eine Benutzeroberfläche ([[GUI]]) haben, (ohne dass sich eine Consolen öffnet) benutzt man unter [[Windows]] <code>javaw.exe</code>. Dieser Interpreter unterdrückt den Start der Kommandozeile.<br />
<br />
Für Programmstarts per Doppelklick sollte also die Verknüpfung in der Windows-Registry auf <code>javaw.exe</code> gesetzt sein. Im folgenden Kapitel gehen wir näher darauf ein.<br />
<br />
===Spezialfall Windows===<br />
[[Datei:ExtMan_Dateiendungen.PNG|mini|Schritt 3 - Dateiendung suchen]]<br />
[[Datei:ExtMan_Erweiterung_bearbeiten.PNG|mini|Schritt 5 - Erweiterung bearbeiten]]<br />
[[Datei:ExtMan_Pfad_zur_JRE.PNG|mini|Schritt 7 - Pfad zur JRE festlegen]]<br />
Unter Windows kann es passieren, dass die richtige Verknüpfung von JRE und Jar-Datei durch falsche Einstellungen oder versehentliches Neuverknüpfen zerstört wird. Jar-Dateien starten dann auch nicht mehr per Doppelklick. <br />
<br />
Das manuelle Beheben des Fehlers durch Eingriff in die Registry gestaltet sich inzwischen mit unter als nicht so trivial, weil mit jeder neuen Windows-Version sich die Struktur der Registry geändert hat. <br />
<br />
Mit Hilfe des kleinen Tools '''ExtMan''' lässt sich das Problem jedoch auf jedem Windows-System prüfen und ggf. reparieren.<br />
<br />
*'''Schritt 1:''' Herunterladen des Programms [https://www.google.de/search?q=extman ExtMan]<br />
<br />
*'''Schritt 2:''' Entpacken und Ausführen des Tools.<br />
<br />
*'''Schritt 3:''' In der Liste der auf dem System registrierten Dateiendungen ''.jar'' suchen und markieren/selektieren<br />
<br />
*'''Schritt 4:''' Auf der rechten Seite den Button ''Erweiterung bearbeiten'' klicken<br />
<br />
*'''Schritt 5:''' Im Bearbeitungsdialog sollte nun bereits die Aktion ''open'' eingetragen sein. Dieser ist nun zu markieren/selektieren. Sollte die Aktion nicht existieren, muss sie angelegt werden. Dazu klicken wir auf ''Neue Aktion'', geben <br />
''open'' ein und bestätigen. Anschließend sollte der Bearbeitungsdialog so aussehen, wie im obigen Bild.<br />
<br />
*'''Schritt 6:''' Dieser Eintrag wird nun bearbeitet. Dazu klicken wir auf den Button ''Bearbeiten''.<br />
<br />
*'''Schritt 7:''' Im unteren Textfeld muss der richtige Pfad zur installierten JRE, sowie einige Platzhalter eingetragen sein bzw. werden. Wir prüfen also auf unserem System zunächst, ob der Pfad zur JRE stimmt. <br />
<br />
*'''Schritt 8:''' Der hier beispielhafte Pfad sollte so in etwa aussehen: <code>"C:\Program Files (x86)\Java\jre1.8.0_151\bin\javaw.exe" -jar "%1" %*</code><br />
<br />
*'''Schritt 9:''' Die Eingabe wird nun mit Klick auf ''Speichern'' übernommen. Auch im jetzt wieder sichtbaren Bearbeitungsdialog bestätigen wir unsere Änderungen mit ''Speichern''.<br />
<br />
*'''Schritt 10:''' Windows muss nun neu gestartet werden, damit die Änderungen in der Registry aktiviert werden. Anschließend sollten Jar-Programme wieder mit Doppelklick ausführbar sein.<br />
<br />
=Fehlermeldungen auf der Java-Console=<br />
<br />
=="Failed to load main class"==<br />
Wenn der Interpreter aus irgendeinem Grund die Start-Klasse ([[Klasse]] mit der main()-[[Methode]]) nicht laden kann, gibt er diese Fehlermeldung aus: "Failed to load main class"<br />
Die Ursachen dafür können recht vielfältig sein. Z.B. ein Fehler in der Manifest-Datei. (Siehe [https://wiki.byte-welt.net/wiki/Jar-Datei_mit_Doppelklick_nicht_ausf%C3%BChrbar%3F#Aufbau_und_Inhalt_von_META-INF Aufbau und Inhalt von META-INF])<br />
<br />
==NoClassDefFoundError==<br />
Wenn eine Klasse beim Kompilieren noch gefunden wurde, aber zur Laufzeit nicht mehr, kommt es zu einem {{JAPI|NoClassDefFoundError}}.<br />
<br />
==ClassNotFoundException==<br />
Dieser Fehler deutet auf ein Problem beim Laden einer Klasse hin. Sie z.B. tritt auf, wenn der {{JAPI|ClassLoader}} eine [[Klasse|Klassendatei]] nicht finden konnte. Nicht alle, in der [[JAR-Datei|Jar-Datei]] gespeicherten Klassen sind im Classpath.<br />
<br />
==NullPointerExecption==<br />
Auch oft anzutreffen, die [[NullPointerException]]. Dieser Ausnahmefehler ist oft auf der Console zu sehen, wenn bspw. eingebundene Resourcen, wie Bilder nicht gefunden wurden und daher Objekte nicht initialisiert werden konnten. Natürlich auch dann, wenn [[Referenz|Referenzen]] auf [[Objekt|Objekte]] noch auf <code>null</code> stehen.<br />
<br />
=Links=<br />
*[[JAR-Datei]]<br />
*[[Java-Programme starten - Möglichkeiten]]<br />
*[[Java Version festlegen]]<br />
*[[Java-Compiler-Level und .class-Datei Versionen (major- und minor version number)]]<br />
<br />
<br />
{{Fragen stellen}}<br />
<br />
[[Kategorie:Java]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=Java-Compiler-Level_und_.class-Datei_Versionen_(major-_und_minor_version_number)&diff=7595Java-Compiler-Level und .class-Datei Versionen (major- und minor version number)2018-02-28T15:10:06Z<p>L-ectron-x: /* Compiler-Level */</p>
<hr />
<div>Der [[Compiler]] erzeugt vom [[JDK]] versionsabhängige Datei-Formate, die der [[Interpreter]] nach bestimmten Merkmalen untersucht, bevor er die [[Klasse]] ausführt.<br />
<br />
Die Versionsnummern geben ihm Aufschluss darüber, ob eine Klasse mit einem kompatiblen JDK kompiliert wurde. Dazu vergleicht er u.a. die major- und die minor version number, welche neben der berühmten magic number (0xCAFEBABE) im Fileheader stehen.<br />
<br />
Nachfolgend werden in einer Übersicht alle bisher veröffentlichten JDKs mit den dazu gehörenden major version und minor version numbers aufgelistet:<br />
{| {{Prettytable}}<br />
! Major Version<br />
! Minor Version<br />
! JDK Version<br />
|-<br />
| 45<br />
| 3<br />
| 1.0<br />
|-<br />
| 45<br />
| 3<br />
| 1.1<br />
|-<br />
| 46<br />
| 0<br />
| 1.2<br />
|-<br />
| 47<br />
| 0<br />
| 1.3<br />
|-<br />
| 48<br />
| 0<br />
| 1.4<br />
|-<br />
| 49<br />
| 0<br />
| 1.5<br />
|-<br />
| 50<br />
| 0<br />
| 1.6<br />
|-<br />
| 51<br />
| 0<br />
| 1.7<br />
|-<br />
| 52<br />
| 0<br />
| 1.8<br />
|-<br />
| 53<br />
| 0<br />
| 1.9<br />
|}<br />
<br />
<br />
'''<span style="color:red;">Eine Java-Anwendung, die mit einem aktuellen JDK kompiliert wurde, läuft nicht in einer älteren JRE.</span>'''<br />
<br />
[[Datei:UnsupportedClassVersionError.jpeg]]<br />
<br />
== Compiler-Level ==<br />
<br />
In den meisten Fällen genügt es bereits, den Compiler-Level auf die Zielplattform auszurichten und neu zu kompilieren.<br />
Das heißt, dass mit einer Compiler-Option eingestellt werden kann, welche JRE-Version ein Programm mindestens benötigt, um ausgeführt zu werden.<br />
<br />
Bsp: Eine Java-Anwendung wurde mit dem JDK 7 geschrieben. Beim Ausführen wird beim Anwender ein {{JAPI|UnsupportedClassVersionError}} in der Java-Konsole ausgegeben. <br />
Der Programmierer hat in seinem Programm nur Klassen aus den JDKs bis Version 6 verwendet. Dann kann er recht einfach die Anzahl der erreichbaren Ziel-VMs vergrößern, indem er den Compiler-Level auf Java 6 einstellt und neu kompiliert. <br />
Die großen [[IDE|IDEs]] wie Eclipse und Netbeans bieten dazu Optionen in den Einstellungen an. Für Java-Editoren muss meist die Option an den Compiler-Aufruf angehängt werden.<br />
<br />
javac -source 1.6 -target 1.6 MeineKlasse.java<br />
<br />
Mit dieser Anweisung akzeptiert der Compiler nur Klassen, die bis zum JDK 6 eingeführt wurden und erzeugt [[Bytecode]] für JREs ab Version 6.<br />
<br />
--[[Benutzer:L-ectron-X|L-ectron-X]] 02:53, 01. Feb 2012 (CET)<br />
<br />
[[Kategorie:Java]]<br />
[[Kategorie:Java Grundlagen]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=Jar-Datei_mit_Doppelklick_nicht_ausf%C3%BChrbar%3F&diff=7594Jar-Datei mit Doppelklick nicht ausführbar?2018-02-28T15:08:42Z<p>L-ectron-x: /* Links */</p>
<hr />
<div>Jar-Dateien ('''J'''ava '''Ar'''chive) sind prinzipiell im Zip-Format komprimierte Dateien, die aber durch spezielle Inhalte erweitert wurden. Per Doppelklick können von der [[JVM]] die in ihnen verpackten Java-Anwendungen ausgeführt werden.<br />
<br />
Du hast eine [[JAR-Datei]] erzeugt oder erhalten und diese lässt sich nicht per Doppelklick starten? Lösungen zu diesem Problem werden wir im Folgenden besprechen.<br />
<br />
=Anwendung oder Bibliothek?=<br />
Jar-Dateien fassen in sich geschlossene Anwendungen oder Bibliotheken (Library) zusammen. Während Bibliotheken nicht ausführbar sind und dazu dienen Funktionalität für ein Programm bereit zu stellen, sind Anwendungen, die in Jar-Dateien gespeichert sind durchaus per Doppelklick ausführbar. <br />
<br />
Ist die Jar-Datei nicht per Doppelklick ausführbar, liegt möglicherweise eine Bibliothek vor. Um das zu prüfen, sieht man sich kurzerhand den Inhalt der Jar-Datei mit einem Packprogramm an.<br />
<br />
'''Grundsätzlich müssen wir uns zu aller erst folgende Frage stellen:'''<br />
'''Ist es nur diese Jar-Datei, die ich nicht starten kann, oder sind alle Jar-Dateien betroffen?'''<br />
<br />
=Problem mit einer bestimmten Jar-Datei=<br />
<br />
==Jar-Datei in der Eingabeaufforderung/Terminal starten==<br />
Um zu testen, ob eine Jar-Datei zumindest fehlerfrei auf der Kommandozeile starten kann, wird folgender Befehl eingegeben:<br />
java -jar MeinJar.jar<br />
''MeinJar.jar'' bezeichnet dabei die auszuführende Jar-Datei. Zum Aufruf muss man sich bereits in dem Verzeichnis befinden, in welchem die Jar-Datei gespeichert wurde.<br />
<br />
Sollte es ein Problem mit der Jar-Datei geben, das die Ausführung verhindert, wird eine Fehlermeldung auf der Console/Eingabeaufforderung/Terminal ausgegeben.<br />
'''Der erste Schritt bei Problemen mit Jar-Dateien sollte also immer sein, zu sehen, ob bei der Ausführung Fehler auf der Console ausgegeben werden.'''<br />
<br />
==Aufbau und Inhalt von META-INF==<br />
Damit eine Jar-Datei ausführbar wird, enthält sie, wie bereits oben beschrieben, weitere spezielle Inhalte, die von der JVM ausgelesen und verarbeitet werden können. Im Wesentlichen handelt es sich dabei um das Verzeichnis ''META-INF'' bzw. um seinen Inhalt. In diesem Verzeichnis muss die [https://wiki.byte-welt.net/wiki/JAR-Datei#MANIFEST.MF Manifest-Datei] enthalten sein. Das Verzeichnis META-INF selbst liegt im Wurzelverzeichnis der Jar-Datei.<br />
<br />
[/]<br />
|__[META-INF]<br />
| |__ MANIFEST.MF<br />
|<br />
|__[mypackage]<br />
|__ Main.class<br />
<br />
Die Manifest-Datei enthält eine Reihe von Informationen, die der Interpreter für die Ausführung einer Java-Anwendung benötigt.<br />
<br />
In der Manifest-Datei müssen, damit eine Java-Anwendung per Jar-Datei ausführbar wird, mindestens folgende Angaben enthalten sein:<br />
<br />
Manifest-Version: 1.0<br />
Main-Class: mypackage.Main<br />
<Leerzeile><br />
<br />
Hinter Main-Class verbirgt sich die [[Klasse]], die die main()-[[Methode]] enthält und damit die Anwendung starten kann. Die Klasse heißt ''Main.class'' und liegt in diesem (obigen) Beispiel im [[Package]] ''mypackage''.<br />
'''Wichtig:''' Ohne eine Leerzeile am Ende der Manifest-Datei wird die Jar-Datei nicht per Mausklick ausführbar sein!<br />
Dieser Fehler tritt oft nur auf, wenn man die Jar-Datei manuell in der Eingabeaufforderung/Terminal erzeugt hat und die Leerzeile vergessen wurde. Eigentlich alle großen Java-[[IDE|IDEs]] können ausführbare Jar-Dateien erzeugen und werden diesen Part richtig machen.<br />
<br />
Wenn wir externe Bibliotheken, wie bspw. einen Datenbanktreiber oder ein [[LookAndFeel]] in unserem Programm benutzen, müssen diese entsprechend im Manifest unserer Jar-Datei eingebunden sein.<br />
<br />
Class-Path: ./db/database.jar ./laf/look-and-feel.jar<br />
<br />
Daher müsste die Zeile '''Class-Path:''' in der Manifest-Datei enthalten sein. In unserem Beispiel sind die eingebundenen Bibliotheken in verschiedenen Verzeichnissen relativ zu unserer Jar-Datei abgelegt.<br><br />
Der Datenbanktreiber liegt, ausgehend vom Verzeichnis unserer Jar-Datei, eine Verzeichnisebene tiefer, im Verzeichnis ''db''. Die Bibliothek des eingesetzten LookAndFeel liegt, ausgehend vom Verzeichnis unserer Jar-Datei, eine Verzeichnisebene tiefer, im Verzeichnis ''laf''.<br />
<br />
Wenn die Bibliotheken für den Java-[[Interpreter]] nicht in den in unserer Manifest-Datei bezeichneten Verzeichnissen zu finden sind, wird ein Fehler auf der Console ausgegeben werden und unsere Jar-Datei ist möglicherweise nicht ausführbar.<br />
<br />
=Generelles Problem mit Jar-Dateien=<br />
Es gibt in allen Betriebssystemen Konstellationen, die verhindern, dass eine Jar-Datei nach einem (Doppel-)Klick mit der Maus auf das Dateisymbol startet.<br />
<br />
*Ist eine aktuelle JRE installiert? Ältere JREs starten Code von neueren Compilern nicht.<br />
<br />
Bei vielen Linux-Distributionen ist bspw. die Jar-Datei mit einem Archivierungsprogramm verknüpft, so dass der Inhalt der Jar-Datei angezeigt wird, statt dass sie gestartet wird.<br />
==Verknüpfung mit dem Java-Interpreter==<br />
Bei Einsatz bestimmter Komprimierungs- bzw. Archivierungsprogramme, wie bspw. [http://www.winrar.de/ WinRar] oder [http://www.7-zip.org/ 7Zip], kommt es gelegentlich aufgrund falscher Programmeinstellungen vor, dass diese Programme statt der gewünschten Jar-Datei beim Doppelklick auf eine Jar-Datei gestartet werden. Statt die Jar-Datei der JVM zu überlassen, leitet das [[Betriebssystem]] den Aufruf an das Packprogramm weiter, welches nun den Inhalt der Jar-Datei anzeigt.<br><br />
In den Einstellungen der Programme sollte nun zur Fehlerbehebung der Haken zum Öffnen von Jar-Dateien entfernt werden.<br />
<br />
Wenn man die Systemeinstellungen seines Linux-Systems nicht ändern möchte, kann man einen [[Programmstarter für Java-Programme anlegen]]. Der Doppelklick auf das angelegte Symbol startet dann das Java-Programm.<br />
<br />
===Interpreter-Typen===<br />
Es gibt zwei verschiedene Java-Interpreter. Zumindest unter [[Windows]]. Unter [[Linux]] gibt es nur einen [[JRE|Interpreter]], dem einerseits in der [[Kommandozeile]] auszuführende Java-Programme übergeben werden können. Andererseits kann man in Linux auch Einstellungen im System festmachen, die dann eine [[JAR-Datei|Jar-Datei]] mit Doppelklick, ohne Console starten können.<br />
<br />
Unter Windows wurden den Interpretern 2 Einsatzzwecke zugedacht. Will man ein Java-Programm auf der Kommandozeile starten, wird <code>java.exe</code> eingesetzt. Dieser Interpreter erzeugt Ausgaben auf der Java-Console bzw. auf der Kommandozeile, so dass bspw. [[Exception (Java)|Java-Fehlermeldungen]] oder Textausgaben, die im Programm mit <code>System.out.println()</code> erzeugt wurden, auf der Kommandozeile landen.<br />
<br />
Wenn man Java-Programme starten möchte, die eine Benutzeroberfläche ([[GUI]]) haben, (ohne dass sich eine Consolen öffnet) benutzt man unter [[Windows]] <code>javaw.exe</code>. Dieser Interpreter unterdrückt den Start der Kommandozeile.<br />
<br />
Für Programmstarts per Doppelklick sollte also die Verknüpfung in der Windows-Registry auf <code>javaw.exe</code> gesetzt sein. Im folgenden Kapitel gehen wir näher darauf ein.<br />
<br />
===Spezialfall Windows===<br />
[[Datei:ExtMan_Dateiendungen.PNG|mini|Schritt 3 - Dateiendung suchen]]<br />
[[Datei:ExtMan_Erweiterung_bearbeiten.PNG|mini|Schritt 5 - Erweiterung bearbeiten]]<br />
[[Datei:ExtMan_Pfad_zur_JRE.PNG|mini|Schritt 7 - Pfad zur JRE festlegen]]<br />
Unter Windows kann es passieren, dass die richtige Verknüpfung von JRE und Jar-Datei durch falsche Einstellungen oder versehentliches Neuverknüpfen zerstört wird. Jar-Dateien starten dann auch nicht mehr per Doppelklick. <br />
<br />
Das manuelle Beheben des Fehlers durch Eingriff in die Registry gestaltet sich inzwischen mit unter als nicht so trivial, weil mit jeder neuen Windows-Version sich die Struktur der Registry geändert hat. <br />
<br />
Mit Hilfe des kleinen Tools '''ExtMan''' lässt sich das Problem jedoch auf jedem Windows-System prüfen und ggf. reparieren.<br />
<br />
*'''Schritt 1:''' Herunterladen des Programms [https://www.google.de/search?q=extman ExtMan]<br />
<br />
*'''Schritt 2:''' Entpacken und Ausführen des Tools.<br />
<br />
*'''Schritt 3:''' In der Liste der auf dem System registrierten Dateiendungen ''.jar'' suchen und markieren/selektieren<br />
<br />
*'''Schritt 4:''' Auf der rechten Seite den Button ''Erweiterung bearbeiten'' klicken<br />
<br />
*'''Schritt 5:''' Im Bearbeitungsdialog sollte nun bereits die Aktion ''open'' eingetragen sein. Dieser ist nun zu markieren/selektieren. Sollte die Aktion nicht existieren, muss sie angelegt werden. Dazu klicken wir auf ''Neue Aktion'', geben <br />
''open'' ein und bestätigen. Anschließend sollte der Bearbeitungsdialog so aussehen, wie im obigen Bild.<br />
<br />
*'''Schritt 6:''' Dieser Eintrag wird nun bearbeitet. Dazu klicken wir auf den Button ''Bearbeiten''.<br />
<br />
*'''Schritt 7:''' Im unteren Textfeld muss der richtige Pfad zur installierten JRE, sowie einige Platzhalter eingetragen sein bzw. werden. Wir prüfen also auf unserem System zunächst, ob der Pfad zur JRE stimmt. <br />
<br />
*'''Schritt 8:''' Der hier beispielhafte Pfad sollte so in etwa aussehen: <code>"C:\Program Files (x86)\Java\jre1.8.0_151\bin\javaw.exe" -jar "%1" %*</code><br />
<br />
*'''Schritt 9:''' Die Eingabe wird nun mit Klick auf ''Speichern'' übernommen. Auch im jetzt wieder sichtbaren Bearbeitungsdialog bestätigen wir unsere Änderungen mit ''Speichern''.<br />
<br />
*'''Schritt 10:''' Windows muss nun neu gestartet werden, damit die Änderungen in der Registry aktiviert werden. Anschließend sollten Jar-Programme wieder mit Doppelklick ausführbar sein.<br />
<br />
=Fehlermeldungen auf der Java-Console=<br />
<br />
=="Failed to load main class"==<br />
Wenn der Interpreter aus irgendeinem Grund die Start-Klasse ([[Klasse]] mit der main()-[[Methode]]) nicht laden kann, gibt er diese Fehlermeldung aus: "Failed to load main class"<br />
Die Ursachen dafür können recht vielfältig sein. Z.B. ein Fehler in der Manifest-Datei. (Siehe [https://wiki.byte-welt.net/wiki/Jar-Datei_mit_Doppelklick_nicht_ausf%C3%BChrbar%3F#Aufbau_und_Inhalt_von_META-INF Aufbau und Inhalt von META-INF])<br />
<br />
==NoClassDefFoundError==<br />
Wenn eine Klasse beim Kompilieren noch gefunden wurde, aber zur Laufzeit nicht mehr, kommt es zu einem {{JAPI|NoClassDefFoundError}}.<br />
<br />
==ClassNotFoundException==<br />
Dieser Fehler deutet auf ein Problem beim Laden einer Klasse hin. Sie z.B. tritt auf, wenn der {{JAPI|ClassLoader}} eine [[Klasse|Klassendatei]] nicht finden konnte. Nicht alle, in der [[JAR-Datei|Jar-Datei]] gespeicherten Klassen sind im Classpath.<br />
<br />
==NullPointerExecption==<br />
Auch oft anzutreffen, die [[NullPointerException]]. Dieser Ausnahmefehler ist oft auf der Console zu sehen, wenn bspw. eingebundene Resourcen, wie Bilder nicht gefunden wurden und daher Objekte nicht initialisiert werden konnten. Natürlich auch dann, wenn [[Referenz|Referenzen]] auf [[Objekt|Objekte]] noch auf <code>null</code> stehen.<br />
<br />
=Links=<br />
*[[JAR-Datei]]<br />
*[[Java-Programme starten - Möglichkeiten]]<br />
*[[Java Version festlegen]]<br />
<br />
<br />
{{Fragen stellen}}<br />
<br />
[[Kategorie:Java]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=Jar-Datei_mit_Doppelklick_nicht_ausf%C3%BChrbar%3F&diff=7593Jar-Datei mit Doppelklick nicht ausführbar?2018-02-28T15:07:07Z<p>L-ectron-x: /* Generelles Problem mit Jar-Dateien */</p>
<hr />
<div>Jar-Dateien ('''J'''ava '''Ar'''chive) sind prinzipiell im Zip-Format komprimierte Dateien, die aber durch spezielle Inhalte erweitert wurden. Per Doppelklick können von der [[JVM]] die in ihnen verpackten Java-Anwendungen ausgeführt werden.<br />
<br />
Du hast eine [[JAR-Datei]] erzeugt oder erhalten und diese lässt sich nicht per Doppelklick starten? Lösungen zu diesem Problem werden wir im Folgenden besprechen.<br />
<br />
=Anwendung oder Bibliothek?=<br />
Jar-Dateien fassen in sich geschlossene Anwendungen oder Bibliotheken (Library) zusammen. Während Bibliotheken nicht ausführbar sind und dazu dienen Funktionalität für ein Programm bereit zu stellen, sind Anwendungen, die in Jar-Dateien gespeichert sind durchaus per Doppelklick ausführbar. <br />
<br />
Ist die Jar-Datei nicht per Doppelklick ausführbar, liegt möglicherweise eine Bibliothek vor. Um das zu prüfen, sieht man sich kurzerhand den Inhalt der Jar-Datei mit einem Packprogramm an.<br />
<br />
'''Grundsätzlich müssen wir uns zu aller erst folgende Frage stellen:'''<br />
'''Ist es nur diese Jar-Datei, die ich nicht starten kann, oder sind alle Jar-Dateien betroffen?'''<br />
<br />
=Problem mit einer bestimmten Jar-Datei=<br />
<br />
==Jar-Datei in der Eingabeaufforderung/Terminal starten==<br />
Um zu testen, ob eine Jar-Datei zumindest fehlerfrei auf der Kommandozeile starten kann, wird folgender Befehl eingegeben:<br />
java -jar MeinJar.jar<br />
''MeinJar.jar'' bezeichnet dabei die auszuführende Jar-Datei. Zum Aufruf muss man sich bereits in dem Verzeichnis befinden, in welchem die Jar-Datei gespeichert wurde.<br />
<br />
Sollte es ein Problem mit der Jar-Datei geben, das die Ausführung verhindert, wird eine Fehlermeldung auf der Console/Eingabeaufforderung/Terminal ausgegeben.<br />
'''Der erste Schritt bei Problemen mit Jar-Dateien sollte also immer sein, zu sehen, ob bei der Ausführung Fehler auf der Console ausgegeben werden.'''<br />
<br />
==Aufbau und Inhalt von META-INF==<br />
Damit eine Jar-Datei ausführbar wird, enthält sie, wie bereits oben beschrieben, weitere spezielle Inhalte, die von der JVM ausgelesen und verarbeitet werden können. Im Wesentlichen handelt es sich dabei um das Verzeichnis ''META-INF'' bzw. um seinen Inhalt. In diesem Verzeichnis muss die [https://wiki.byte-welt.net/wiki/JAR-Datei#MANIFEST.MF Manifest-Datei] enthalten sein. Das Verzeichnis META-INF selbst liegt im Wurzelverzeichnis der Jar-Datei.<br />
<br />
[/]<br />
|__[META-INF]<br />
| |__ MANIFEST.MF<br />
|<br />
|__[mypackage]<br />
|__ Main.class<br />
<br />
Die Manifest-Datei enthält eine Reihe von Informationen, die der Interpreter für die Ausführung einer Java-Anwendung benötigt.<br />
<br />
In der Manifest-Datei müssen, damit eine Java-Anwendung per Jar-Datei ausführbar wird, mindestens folgende Angaben enthalten sein:<br />
<br />
Manifest-Version: 1.0<br />
Main-Class: mypackage.Main<br />
<Leerzeile><br />
<br />
Hinter Main-Class verbirgt sich die [[Klasse]], die die main()-[[Methode]] enthält und damit die Anwendung starten kann. Die Klasse heißt ''Main.class'' und liegt in diesem (obigen) Beispiel im [[Package]] ''mypackage''.<br />
'''Wichtig:''' Ohne eine Leerzeile am Ende der Manifest-Datei wird die Jar-Datei nicht per Mausklick ausführbar sein!<br />
Dieser Fehler tritt oft nur auf, wenn man die Jar-Datei manuell in der Eingabeaufforderung/Terminal erzeugt hat und die Leerzeile vergessen wurde. Eigentlich alle großen Java-[[IDE|IDEs]] können ausführbare Jar-Dateien erzeugen und werden diesen Part richtig machen.<br />
<br />
Wenn wir externe Bibliotheken, wie bspw. einen Datenbanktreiber oder ein [[LookAndFeel]] in unserem Programm benutzen, müssen diese entsprechend im Manifest unserer Jar-Datei eingebunden sein.<br />
<br />
Class-Path: ./db/database.jar ./laf/look-and-feel.jar<br />
<br />
Daher müsste die Zeile '''Class-Path:''' in der Manifest-Datei enthalten sein. In unserem Beispiel sind die eingebundenen Bibliotheken in verschiedenen Verzeichnissen relativ zu unserer Jar-Datei abgelegt.<br><br />
Der Datenbanktreiber liegt, ausgehend vom Verzeichnis unserer Jar-Datei, eine Verzeichnisebene tiefer, im Verzeichnis ''db''. Die Bibliothek des eingesetzten LookAndFeel liegt, ausgehend vom Verzeichnis unserer Jar-Datei, eine Verzeichnisebene tiefer, im Verzeichnis ''laf''.<br />
<br />
Wenn die Bibliotheken für den Java-[[Interpreter]] nicht in den in unserer Manifest-Datei bezeichneten Verzeichnissen zu finden sind, wird ein Fehler auf der Console ausgegeben werden und unsere Jar-Datei ist möglicherweise nicht ausführbar.<br />
<br />
=Generelles Problem mit Jar-Dateien=<br />
Es gibt in allen Betriebssystemen Konstellationen, die verhindern, dass eine Jar-Datei nach einem (Doppel-)Klick mit der Maus auf das Dateisymbol startet.<br />
<br />
*Ist eine aktuelle JRE installiert? Ältere JREs starten Code von neueren Compilern nicht.<br />
<br />
Bei vielen Linux-Distributionen ist bspw. die Jar-Datei mit einem Archivierungsprogramm verknüpft, so dass der Inhalt der Jar-Datei angezeigt wird, statt dass sie gestartet wird.<br />
==Verknüpfung mit dem Java-Interpreter==<br />
Bei Einsatz bestimmter Komprimierungs- bzw. Archivierungsprogramme, wie bspw. [http://www.winrar.de/ WinRar] oder [http://www.7-zip.org/ 7Zip], kommt es gelegentlich aufgrund falscher Programmeinstellungen vor, dass diese Programme statt der gewünschten Jar-Datei beim Doppelklick auf eine Jar-Datei gestartet werden. Statt die Jar-Datei der JVM zu überlassen, leitet das [[Betriebssystem]] den Aufruf an das Packprogramm weiter, welches nun den Inhalt der Jar-Datei anzeigt.<br><br />
In den Einstellungen der Programme sollte nun zur Fehlerbehebung der Haken zum Öffnen von Jar-Dateien entfernt werden.<br />
<br />
Wenn man die Systemeinstellungen seines Linux-Systems nicht ändern möchte, kann man einen [[Programmstarter für Java-Programme anlegen]]. Der Doppelklick auf das angelegte Symbol startet dann das Java-Programm.<br />
<br />
===Interpreter-Typen===<br />
Es gibt zwei verschiedene Java-Interpreter. Zumindest unter [[Windows]]. Unter [[Linux]] gibt es nur einen [[JRE|Interpreter]], dem einerseits in der [[Kommandozeile]] auszuführende Java-Programme übergeben werden können. Andererseits kann man in Linux auch Einstellungen im System festmachen, die dann eine [[JAR-Datei|Jar-Datei]] mit Doppelklick, ohne Console starten können.<br />
<br />
Unter Windows wurden den Interpretern 2 Einsatzzwecke zugedacht. Will man ein Java-Programm auf der Kommandozeile starten, wird <code>java.exe</code> eingesetzt. Dieser Interpreter erzeugt Ausgaben auf der Java-Console bzw. auf der Kommandozeile, so dass bspw. [[Exception (Java)|Java-Fehlermeldungen]] oder Textausgaben, die im Programm mit <code>System.out.println()</code> erzeugt wurden, auf der Kommandozeile landen.<br />
<br />
Wenn man Java-Programme starten möchte, die eine Benutzeroberfläche ([[GUI]]) haben, (ohne dass sich eine Consolen öffnet) benutzt man unter [[Windows]] <code>javaw.exe</code>. Dieser Interpreter unterdrückt den Start der Kommandozeile.<br />
<br />
Für Programmstarts per Doppelklick sollte also die Verknüpfung in der Windows-Registry auf <code>javaw.exe</code> gesetzt sein. Im folgenden Kapitel gehen wir näher darauf ein.<br />
<br />
===Spezialfall Windows===<br />
[[Datei:ExtMan_Dateiendungen.PNG|mini|Schritt 3 - Dateiendung suchen]]<br />
[[Datei:ExtMan_Erweiterung_bearbeiten.PNG|mini|Schritt 5 - Erweiterung bearbeiten]]<br />
[[Datei:ExtMan_Pfad_zur_JRE.PNG|mini|Schritt 7 - Pfad zur JRE festlegen]]<br />
Unter Windows kann es passieren, dass die richtige Verknüpfung von JRE und Jar-Datei durch falsche Einstellungen oder versehentliches Neuverknüpfen zerstört wird. Jar-Dateien starten dann auch nicht mehr per Doppelklick. <br />
<br />
Das manuelle Beheben des Fehlers durch Eingriff in die Registry gestaltet sich inzwischen mit unter als nicht so trivial, weil mit jeder neuen Windows-Version sich die Struktur der Registry geändert hat. <br />
<br />
Mit Hilfe des kleinen Tools '''ExtMan''' lässt sich das Problem jedoch auf jedem Windows-System prüfen und ggf. reparieren.<br />
<br />
*'''Schritt 1:''' Herunterladen des Programms [https://www.google.de/search?q=extman ExtMan]<br />
<br />
*'''Schritt 2:''' Entpacken und Ausführen des Tools.<br />
<br />
*'''Schritt 3:''' In der Liste der auf dem System registrierten Dateiendungen ''.jar'' suchen und markieren/selektieren<br />
<br />
*'''Schritt 4:''' Auf der rechten Seite den Button ''Erweiterung bearbeiten'' klicken<br />
<br />
*'''Schritt 5:''' Im Bearbeitungsdialog sollte nun bereits die Aktion ''open'' eingetragen sein. Dieser ist nun zu markieren/selektieren. Sollte die Aktion nicht existieren, muss sie angelegt werden. Dazu klicken wir auf ''Neue Aktion'', geben <br />
''open'' ein und bestätigen. Anschließend sollte der Bearbeitungsdialog so aussehen, wie im obigen Bild.<br />
<br />
*'''Schritt 6:''' Dieser Eintrag wird nun bearbeitet. Dazu klicken wir auf den Button ''Bearbeiten''.<br />
<br />
*'''Schritt 7:''' Im unteren Textfeld muss der richtige Pfad zur installierten JRE, sowie einige Platzhalter eingetragen sein bzw. werden. Wir prüfen also auf unserem System zunächst, ob der Pfad zur JRE stimmt. <br />
<br />
*'''Schritt 8:''' Der hier beispielhafte Pfad sollte so in etwa aussehen: <code>"C:\Program Files (x86)\Java\jre1.8.0_151\bin\javaw.exe" -jar "%1" %*</code><br />
<br />
*'''Schritt 9:''' Die Eingabe wird nun mit Klick auf ''Speichern'' übernommen. Auch im jetzt wieder sichtbaren Bearbeitungsdialog bestätigen wir unsere Änderungen mit ''Speichern''.<br />
<br />
*'''Schritt 10:''' Windows muss nun neu gestartet werden, damit die Änderungen in der Registry aktiviert werden. Anschließend sollten Jar-Programme wieder mit Doppelklick ausführbar sein.<br />
<br />
=Fehlermeldungen auf der Java-Console=<br />
<br />
=="Failed to load main class"==<br />
Wenn der Interpreter aus irgendeinem Grund die Start-Klasse ([[Klasse]] mit der main()-[[Methode]]) nicht laden kann, gibt er diese Fehlermeldung aus: "Failed to load main class"<br />
Die Ursachen dafür können recht vielfältig sein. Z.B. ein Fehler in der Manifest-Datei. (Siehe [https://wiki.byte-welt.net/wiki/Jar-Datei_mit_Doppelklick_nicht_ausf%C3%BChrbar%3F#Aufbau_und_Inhalt_von_META-INF Aufbau und Inhalt von META-INF])<br />
<br />
==NoClassDefFoundError==<br />
Wenn eine Klasse beim Kompilieren noch gefunden wurde, aber zur Laufzeit nicht mehr, kommt es zu einem {{JAPI|NoClassDefFoundError}}.<br />
<br />
==ClassNotFoundException==<br />
Dieser Fehler deutet auf ein Problem beim Laden einer Klasse hin. Sie z.B. tritt auf, wenn der {{JAPI|ClassLoader}} eine [[Klasse|Klassendatei]] nicht finden konnte. Nicht alle, in der [[JAR-Datei|Jar-Datei]] gespeicherten Klassen sind im Classpath.<br />
<br />
==NullPointerExecption==<br />
Auch oft anzutreffen, die [[NullPointerException]]. Dieser Ausnahmefehler ist oft auf der Console zu sehen, wenn bspw. eingebundene Resourcen, wie Bilder nicht gefunden wurden und daher Objekte nicht initialisiert werden konnten. Natürlich auch dann, wenn [[Referenz|Referenzen]] auf [[Objekt|Objekte]] noch auf <code>null</code> stehen.<br />
<br />
=Links=<br />
*[[Java-Programme starten - Möglichkeiten]]<br />
*[[Java-Programm nur einmal starten]]<br />
<br />
<br />
{{Fragen stellen}}<br />
<br />
[[Kategorie:Java]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=Jar-Datei_mit_Doppelklick_nicht_ausf%C3%BChrbar%3F&diff=7592Jar-Datei mit Doppelklick nicht ausführbar?2018-02-28T14:59:53Z<p>L-ectron-x: /* Aufbau und Inhalt von META-INF */</p>
<hr />
<div>Jar-Dateien ('''J'''ava '''Ar'''chive) sind prinzipiell im Zip-Format komprimierte Dateien, die aber durch spezielle Inhalte erweitert wurden. Per Doppelklick können von der [[JVM]] die in ihnen verpackten Java-Anwendungen ausgeführt werden.<br />
<br />
Du hast eine [[JAR-Datei]] erzeugt oder erhalten und diese lässt sich nicht per Doppelklick starten? Lösungen zu diesem Problem werden wir im Folgenden besprechen.<br />
<br />
=Anwendung oder Bibliothek?=<br />
Jar-Dateien fassen in sich geschlossene Anwendungen oder Bibliotheken (Library) zusammen. Während Bibliotheken nicht ausführbar sind und dazu dienen Funktionalität für ein Programm bereit zu stellen, sind Anwendungen, die in Jar-Dateien gespeichert sind durchaus per Doppelklick ausführbar. <br />
<br />
Ist die Jar-Datei nicht per Doppelklick ausführbar, liegt möglicherweise eine Bibliothek vor. Um das zu prüfen, sieht man sich kurzerhand den Inhalt der Jar-Datei mit einem Packprogramm an.<br />
<br />
'''Grundsätzlich müssen wir uns zu aller erst folgende Frage stellen:'''<br />
'''Ist es nur diese Jar-Datei, die ich nicht starten kann, oder sind alle Jar-Dateien betroffen?'''<br />
<br />
=Problem mit einer bestimmten Jar-Datei=<br />
<br />
==Jar-Datei in der Eingabeaufforderung/Terminal starten==<br />
Um zu testen, ob eine Jar-Datei zumindest fehlerfrei auf der Kommandozeile starten kann, wird folgender Befehl eingegeben:<br />
java -jar MeinJar.jar<br />
''MeinJar.jar'' bezeichnet dabei die auszuführende Jar-Datei. Zum Aufruf muss man sich bereits in dem Verzeichnis befinden, in welchem die Jar-Datei gespeichert wurde.<br />
<br />
Sollte es ein Problem mit der Jar-Datei geben, das die Ausführung verhindert, wird eine Fehlermeldung auf der Console/Eingabeaufforderung/Terminal ausgegeben.<br />
'''Der erste Schritt bei Problemen mit Jar-Dateien sollte also immer sein, zu sehen, ob bei der Ausführung Fehler auf der Console ausgegeben werden.'''<br />
<br />
==Aufbau und Inhalt von META-INF==<br />
Damit eine Jar-Datei ausführbar wird, enthält sie, wie bereits oben beschrieben, weitere spezielle Inhalte, die von der JVM ausgelesen und verarbeitet werden können. Im Wesentlichen handelt es sich dabei um das Verzeichnis ''META-INF'' bzw. um seinen Inhalt. In diesem Verzeichnis muss die [https://wiki.byte-welt.net/wiki/JAR-Datei#MANIFEST.MF Manifest-Datei] enthalten sein. Das Verzeichnis META-INF selbst liegt im Wurzelverzeichnis der Jar-Datei.<br />
<br />
[/]<br />
|__[META-INF]<br />
| |__ MANIFEST.MF<br />
|<br />
|__[mypackage]<br />
|__ Main.class<br />
<br />
Die Manifest-Datei enthält eine Reihe von Informationen, die der Interpreter für die Ausführung einer Java-Anwendung benötigt.<br />
<br />
In der Manifest-Datei müssen, damit eine Java-Anwendung per Jar-Datei ausführbar wird, mindestens folgende Angaben enthalten sein:<br />
<br />
Manifest-Version: 1.0<br />
Main-Class: mypackage.Main<br />
<Leerzeile><br />
<br />
Hinter Main-Class verbirgt sich die [[Klasse]], die die main()-[[Methode]] enthält und damit die Anwendung starten kann. Die Klasse heißt ''Main.class'' und liegt in diesem (obigen) Beispiel im [[Package]] ''mypackage''.<br />
'''Wichtig:''' Ohne eine Leerzeile am Ende der Manifest-Datei wird die Jar-Datei nicht per Mausklick ausführbar sein!<br />
Dieser Fehler tritt oft nur auf, wenn man die Jar-Datei manuell in der Eingabeaufforderung/Terminal erzeugt hat und die Leerzeile vergessen wurde. Eigentlich alle großen Java-[[IDE|IDEs]] können ausführbare Jar-Dateien erzeugen und werden diesen Part richtig machen.<br />
<br />
Wenn wir externe Bibliotheken, wie bspw. einen Datenbanktreiber oder ein [[LookAndFeel]] in unserem Programm benutzen, müssen diese entsprechend im Manifest unserer Jar-Datei eingebunden sein.<br />
<br />
Class-Path: ./db/database.jar ./laf/look-and-feel.jar<br />
<br />
Daher müsste die Zeile '''Class-Path:''' in der Manifest-Datei enthalten sein. In unserem Beispiel sind die eingebundenen Bibliotheken in verschiedenen Verzeichnissen relativ zu unserer Jar-Datei abgelegt.<br><br />
Der Datenbanktreiber liegt, ausgehend vom Verzeichnis unserer Jar-Datei, eine Verzeichnisebene tiefer, im Verzeichnis ''db''. Die Bibliothek des eingesetzten LookAndFeel liegt, ausgehend vom Verzeichnis unserer Jar-Datei, eine Verzeichnisebene tiefer, im Verzeichnis ''laf''.<br />
<br />
Wenn die Bibliotheken für den Java-[[Interpreter]] nicht in den in unserer Manifest-Datei bezeichneten Verzeichnissen zu finden sind, wird ein Fehler auf der Console ausgegeben werden und unsere Jar-Datei ist möglicherweise nicht ausführbar.<br />
<br />
=Generelles Problem mit Jar-Dateien=<br />
Es gibt in allen Betriebssystemen Konstellationen, die verhindern, dass eine Jar-Datei nach einem (Doppel-)Klick mit der Maus auf das Dateisymbol startet.<br />
<br />
Bei vielen Linux-Distributionen ist bspw. die Jar-Datei mit einem Archivierungsprogramm verknüpft, so dass der Inhalt der Jar-Datei angezeigt wird, statt dass sie gestartet wird.<br />
==Verknüpfung mit dem Java-Interpreter==<br />
Bei Einsatz bestimmter Komprimierungs- bzw. Archivierungsprogramme, wie bspw. [http://www.winrar.de/ WinRar] oder [http://www.7-zip.org/ 7Zip], kommt es gelegentlich aufgrund falscher Programmeinstellungen vor, dass diese Programme statt der gewünschten Jar-Datei beim Doppelklick auf eine Jar-Datei gestartet werden. Statt die Jar-Datei der JVM zu überlassen, leitet das [[Betriebssystem]] den Aufruf an das Packprogramm weiter, welches nun den Inhalt der Jar-Datei anzeigt.<br><br />
In den Einstellungen der Programme sollte nun zur Fehlerbehebung der Haken zum Öffnen von Jar-Dateien entfernt werden.<br />
<br />
Wenn man die Systemeinstellungen seines Linux-Systems nicht ändern möchte, kann man einen [[Programmstarter für Java-Programme anlegen]]. Der Doppelklick auf das angelegte Symbol startet dann das Java-Programm.<br />
<br />
===Interpreter-Typen===<br />
Es gibt zwei verschiedene Java-Interpreter. Zumindest unter [[Windows]]. Unter [[Linux]] gibt es nur einen [[JRE|Interpreter]], dem einerseits in der [[Kommandozeile]] auszuführende Java-Programme übergeben werden können. Andererseits kann man in Linux auch Einstellungen im System festmachen, die dann eine [[JAR-Datei|Jar-Datei]] mit Doppelklick, ohne Console starten können.<br />
<br />
Unter Windows wurden den Interpretern 2 Einsatzzwecke zugedacht. Will man ein Java-Programm auf der Kommandozeile starten, wird <code>java.exe</code> eingesetzt. Dieser Interpreter erzeugt Ausgaben auf der Java-Console bzw. auf der Kommandozeile, so dass bspw. [[Exception (Java)|Java-Fehlermeldungen]] oder Textausgaben, die im Programm mit <code>System.out.println()</code> erzeugt wurden, auf der Kommandozeile landen.<br />
<br />
Wenn man Java-Programme starten möchte, die eine Benutzeroberfläche ([[GUI]]) haben, (ohne dass sich eine Consolen öffnet) benutzt man unter [[Windows]] <code>javaw.exe</code>. Dieser Interpreter unterdrückt den Start der Kommandozeile.<br />
<br />
Für Programmstarts per Doppelklick sollte also die Verknüpfung in der Windows-Registry auf <code>javaw.exe</code> gesetzt sein. Im folgenden Kapitel gehen wir näher darauf ein.<br />
<br />
===Spezialfall Windows===<br />
[[Datei:ExtMan_Dateiendungen.PNG|mini|Schritt 3 - Dateiendung suchen]]<br />
[[Datei:ExtMan_Erweiterung_bearbeiten.PNG|mini|Schritt 5 - Erweiterung bearbeiten]]<br />
[[Datei:ExtMan_Pfad_zur_JRE.PNG|mini|Schritt 7 - Pfad zur JRE festlegen]]<br />
Unter Windows kann es passieren, dass die richtige Verknüpfung von JRE und Jar-Datei durch falsche Einstellungen oder versehentliches Neuverknüpfen zerstört wird. Jar-Dateien starten dann auch nicht mehr per Doppelklick. <br />
<br />
Das manuelle Beheben des Fehlers durch Eingriff in die Registry gestaltet sich inzwischen mit unter als nicht so trivial, weil mit jeder neuen Windows-Version sich die Struktur der Registry geändert hat. <br />
<br />
Mit Hilfe des kleinen Tools '''ExtMan''' lässt sich das Problem jedoch auf jedem Windows-System prüfen und ggf. reparieren.<br />
<br />
*'''Schritt 1:''' Herunterladen des Programms [https://www.google.de/search?q=extman ExtMan]<br />
<br />
*'''Schritt 2:''' Entpacken und Ausführen des Tools.<br />
<br />
*'''Schritt 3:''' In der Liste der auf dem System registrierten Dateiendungen ''.jar'' suchen und markieren/selektieren<br />
<br />
*'''Schritt 4:''' Auf der rechten Seite den Button ''Erweiterung bearbeiten'' klicken<br />
<br />
*'''Schritt 5:''' Im Bearbeitungsdialog sollte nun bereits die Aktion ''open'' eingetragen sein. Dieser ist nun zu markieren/selektieren. Sollte die Aktion nicht existieren, muss sie angelegt werden. Dazu klicken wir auf ''Neue Aktion'', geben <br />
''open'' ein und bestätigen. Anschließend sollte der Bearbeitungsdialog so aussehen, wie im obigen Bild.<br />
<br />
*'''Schritt 6:''' Dieser Eintrag wird nun bearbeitet. Dazu klicken wir auf den Button ''Bearbeiten''.<br />
<br />
*'''Schritt 7:''' Im unteren Textfeld muss der richtige Pfad zur installierten JRE, sowie einige Platzhalter eingetragen sein bzw. werden. Wir prüfen also auf unserem System zunächst, ob der Pfad zur JRE stimmt. <br />
<br />
*'''Schritt 8:''' Der hier beispielhafte Pfad sollte so in etwa aussehen: <code>"C:\Program Files (x86)\Java\jre1.8.0_151\bin\javaw.exe" -jar "%1" %*</code><br />
<br />
*'''Schritt 9:''' Die Eingabe wird nun mit Klick auf ''Speichern'' übernommen. Auch im jetzt wieder sichtbaren Bearbeitungsdialog bestätigen wir unsere Änderungen mit ''Speichern''.<br />
<br />
*'''Schritt 10:''' Windows muss nun neu gestartet werden, damit die Änderungen in der Registry aktiviert werden. Anschließend sollten Jar-Programme wieder mit Doppelklick ausführbar sein.<br />
<br />
=Fehlermeldungen auf der Java-Console=<br />
<br />
=="Failed to load main class"==<br />
Wenn der Interpreter aus irgendeinem Grund die Start-Klasse ([[Klasse]] mit der main()-[[Methode]]) nicht laden kann, gibt er diese Fehlermeldung aus: "Failed to load main class"<br />
Die Ursachen dafür können recht vielfältig sein. Z.B. ein Fehler in der Manifest-Datei. (Siehe [https://wiki.byte-welt.net/wiki/Jar-Datei_mit_Doppelklick_nicht_ausf%C3%BChrbar%3F#Aufbau_und_Inhalt_von_META-INF Aufbau und Inhalt von META-INF])<br />
<br />
==NoClassDefFoundError==<br />
Wenn eine Klasse beim Kompilieren noch gefunden wurde, aber zur Laufzeit nicht mehr, kommt es zu einem {{JAPI|NoClassDefFoundError}}.<br />
<br />
==ClassNotFoundException==<br />
Dieser Fehler deutet auf ein Problem beim Laden einer Klasse hin. Sie z.B. tritt auf, wenn der {{JAPI|ClassLoader}} eine [[Klasse|Klassendatei]] nicht finden konnte. Nicht alle, in der [[JAR-Datei|Jar-Datei]] gespeicherten Klassen sind im Classpath.<br />
<br />
==NullPointerExecption==<br />
Auch oft anzutreffen, die [[NullPointerException]]. Dieser Ausnahmefehler ist oft auf der Console zu sehen, wenn bspw. eingebundene Resourcen, wie Bilder nicht gefunden wurden und daher Objekte nicht initialisiert werden konnten. Natürlich auch dann, wenn [[Referenz|Referenzen]] auf [[Objekt|Objekte]] noch auf <code>null</code> stehen.<br />
<br />
=Links=<br />
*[[Java-Programme starten - Möglichkeiten]]<br />
*[[Java-Programm nur einmal starten]]<br />
<br />
<br />
{{Fragen stellen}}<br />
<br />
[[Kategorie:Java]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=Jar-Datei_mit_Doppelklick_nicht_ausf%C3%BChrbar%3F&diff=7591Jar-Datei mit Doppelklick nicht ausführbar?2018-02-28T14:59:00Z<p>L-ectron-x: /* Aufbau und Inhalt von META-INF */</p>
<hr />
<div>Jar-Dateien ('''J'''ava '''Ar'''chive) sind prinzipiell im Zip-Format komprimierte Dateien, die aber durch spezielle Inhalte erweitert wurden. Per Doppelklick können von der [[JVM]] die in ihnen verpackten Java-Anwendungen ausgeführt werden.<br />
<br />
Du hast eine [[JAR-Datei]] erzeugt oder erhalten und diese lässt sich nicht per Doppelklick starten? Lösungen zu diesem Problem werden wir im Folgenden besprechen.<br />
<br />
=Anwendung oder Bibliothek?=<br />
Jar-Dateien fassen in sich geschlossene Anwendungen oder Bibliotheken (Library) zusammen. Während Bibliotheken nicht ausführbar sind und dazu dienen Funktionalität für ein Programm bereit zu stellen, sind Anwendungen, die in Jar-Dateien gespeichert sind durchaus per Doppelklick ausführbar. <br />
<br />
Ist die Jar-Datei nicht per Doppelklick ausführbar, liegt möglicherweise eine Bibliothek vor. Um das zu prüfen, sieht man sich kurzerhand den Inhalt der Jar-Datei mit einem Packprogramm an.<br />
<br />
'''Grundsätzlich müssen wir uns zu aller erst folgende Frage stellen:'''<br />
'''Ist es nur diese Jar-Datei, die ich nicht starten kann, oder sind alle Jar-Dateien betroffen?'''<br />
<br />
=Problem mit einer bestimmten Jar-Datei=<br />
<br />
==Jar-Datei in der Eingabeaufforderung/Terminal starten==<br />
Um zu testen, ob eine Jar-Datei zumindest fehlerfrei auf der Kommandozeile starten kann, wird folgender Befehl eingegeben:<br />
java -jar MeinJar.jar<br />
''MeinJar.jar'' bezeichnet dabei die auszuführende Jar-Datei. Zum Aufruf muss man sich bereits in dem Verzeichnis befinden, in welchem die Jar-Datei gespeichert wurde.<br />
<br />
Sollte es ein Problem mit der Jar-Datei geben, das die Ausführung verhindert, wird eine Fehlermeldung auf der Console/Eingabeaufforderung/Terminal ausgegeben.<br />
'''Der erste Schritt bei Problemen mit Jar-Dateien sollte also immer sein, zu sehen, ob bei der Ausführung Fehler auf der Console ausgegeben werden.'''<br />
<br />
==Aufbau und Inhalt von META-INF==<br />
Damit eine Jar-Datei ausführbar wird, enthält sie, wie bereits oben beschrieben, weitere spezielle Inhalte, die von der JVM ausgelesen und verarbeitet werden können. Im Wesentlichen handelt es sich dabei um das Verzeichnis ''META-INF'' bzw. um seinen Inhalt. In diesem Verzeichnis muss die [https://wiki.byte-welt.net/wiki/JAR-Datei#MANIFEST.MF Manifest-Datei] enthalten sein. Das Verzeichnis META-INF selbst liegt im Wurzelverzeichnis der Jar-Datei.<br />
<br />
[/]<br />
|__[META-INF]<br />
| |__ MANIFEST.MF<br />
|<br />
|__[mypackage]<br />
|__ Main.class<br />
<br />
Die Manifest-Datei enthält eine Reihe von Informationen, die der Interpreter für die Ausführung einer Java-Anwendung benötigt.<br />
<br />
In der Manifest-Datei müssen, damit eine Java-Anwendung per Jar-Datei ausführbar wird, mindestens folgende Angaben enthalten sein:<br />
Manifest-Version: 1.0<br />
Main-Class: mypackage.Main<br />
<Leerzeile><br />
Hinter Main-Class verbirgt sich die [[Klasse]], die die main()-[[Methode]] enthält und damit die Anwendung starten kann. Die Klasse heißt ''Main.class'' und liegt in diesem (obigen) Beispiel im [[Package]] ''mypackage''.<br />
'''Wichtig:''' Ohne eine Leerzeile am Ende der Manifest-Datei wird die Jar-Datei nicht per Mausklick ausführbar sein!<br />
Dieser Fehler tritt oft nur auf, wenn man die Jar-Datei manuell in der Eingabeaufforderung/Terminal erzeugt hat und die Leerzeile vergessen wurde. Eigentlich alle großen Java-[[IDE|IDEs]] können ausführbare Jar-Dateien erzeugen und werden diesen Part richtig machen.<br />
<br />
Wenn wir externe Bibliotheken, wie bspw. einen Datenbanktreiber oder ein [[LookAndFeel]] in unserem Programm benutzen, müssen diese entsprechend im Manifest unserer Jar-Datei eingebunden sein.<br />
<code=ini><br />
Class-Path: ./db/database.jar ./laf/look-and-feel.jar<br />
</code=ini><br />
Daher müsste die Zeile '''Class-Path:''' in der Manifest-Datei enthalten sein. In unserem Beispiel sind die eingebundenen Bibliotheken in verschiedenen Verzeichnissen relativ zu unserer Jar-Datei abgelegt.<br><br />
Der Datenbanktreiber liegt, ausgehend vom Verzeichnis unserer Jar-Datei, eine Verzeichnisebene tiefer, im Verzeichnis ''db''. Die Bibliothek des eingesetzten LookAndFeel liegt, ausgehend vom Verzeichnis unserer Jar-Datei, eine Verzeichnisebene tiefer, im Verzeichnis ''laf''.<br />
<br />
Wenn die Bibliotheken für den Java-[[Interpreter]] nicht in den in unserer Manifest-Datei bezeichneten Verzeichnissen zu finden sind, wird ein Fehler auf der Console ausgegeben werden und unsere Jar-Datei ist möglicherweise nicht ausführbar.<br />
<br />
=Generelles Problem mit Jar-Dateien=<br />
Es gibt in allen Betriebssystemen Konstellationen, die verhindern, dass eine Jar-Datei nach einem (Doppel-)Klick mit der Maus auf das Dateisymbol startet.<br />
<br />
Bei vielen Linux-Distributionen ist bspw. die Jar-Datei mit einem Archivierungsprogramm verknüpft, so dass der Inhalt der Jar-Datei angezeigt wird, statt dass sie gestartet wird.<br />
==Verknüpfung mit dem Java-Interpreter==<br />
Bei Einsatz bestimmter Komprimierungs- bzw. Archivierungsprogramme, wie bspw. [http://www.winrar.de/ WinRar] oder [http://www.7-zip.org/ 7Zip], kommt es gelegentlich aufgrund falscher Programmeinstellungen vor, dass diese Programme statt der gewünschten Jar-Datei beim Doppelklick auf eine Jar-Datei gestartet werden. Statt die Jar-Datei der JVM zu überlassen, leitet das [[Betriebssystem]] den Aufruf an das Packprogramm weiter, welches nun den Inhalt der Jar-Datei anzeigt.<br><br />
In den Einstellungen der Programme sollte nun zur Fehlerbehebung der Haken zum Öffnen von Jar-Dateien entfernt werden.<br />
<br />
Wenn man die Systemeinstellungen seines Linux-Systems nicht ändern möchte, kann man einen [[Programmstarter für Java-Programme anlegen]]. Der Doppelklick auf das angelegte Symbol startet dann das Java-Programm.<br />
<br />
===Interpreter-Typen===<br />
Es gibt zwei verschiedene Java-Interpreter. Zumindest unter [[Windows]]. Unter [[Linux]] gibt es nur einen [[JRE|Interpreter]], dem einerseits in der [[Kommandozeile]] auszuführende Java-Programme übergeben werden können. Andererseits kann man in Linux auch Einstellungen im System festmachen, die dann eine [[JAR-Datei|Jar-Datei]] mit Doppelklick, ohne Console starten können.<br />
<br />
Unter Windows wurden den Interpretern 2 Einsatzzwecke zugedacht. Will man ein Java-Programm auf der Kommandozeile starten, wird <code>java.exe</code> eingesetzt. Dieser Interpreter erzeugt Ausgaben auf der Java-Console bzw. auf der Kommandozeile, so dass bspw. [[Exception (Java)|Java-Fehlermeldungen]] oder Textausgaben, die im Programm mit <code>System.out.println()</code> erzeugt wurden, auf der Kommandozeile landen.<br />
<br />
Wenn man Java-Programme starten möchte, die eine Benutzeroberfläche ([[GUI]]) haben, (ohne dass sich eine Consolen öffnet) benutzt man unter [[Windows]] <code>javaw.exe</code>. Dieser Interpreter unterdrückt den Start der Kommandozeile.<br />
<br />
Für Programmstarts per Doppelklick sollte also die Verknüpfung in der Windows-Registry auf <code>javaw.exe</code> gesetzt sein. Im folgenden Kapitel gehen wir näher darauf ein.<br />
<br />
===Spezialfall Windows===<br />
[[Datei:ExtMan_Dateiendungen.PNG|mini|Schritt 3 - Dateiendung suchen]]<br />
[[Datei:ExtMan_Erweiterung_bearbeiten.PNG|mini|Schritt 5 - Erweiterung bearbeiten]]<br />
[[Datei:ExtMan_Pfad_zur_JRE.PNG|mini|Schritt 7 - Pfad zur JRE festlegen]]<br />
Unter Windows kann es passieren, dass die richtige Verknüpfung von JRE und Jar-Datei durch falsche Einstellungen oder versehentliches Neuverknüpfen zerstört wird. Jar-Dateien starten dann auch nicht mehr per Doppelklick. <br />
<br />
Das manuelle Beheben des Fehlers durch Eingriff in die Registry gestaltet sich inzwischen mit unter als nicht so trivial, weil mit jeder neuen Windows-Version sich die Struktur der Registry geändert hat. <br />
<br />
Mit Hilfe des kleinen Tools '''ExtMan''' lässt sich das Problem jedoch auf jedem Windows-System prüfen und ggf. reparieren.<br />
<br />
*'''Schritt 1:''' Herunterladen des Programms [https://www.google.de/search?q=extman ExtMan]<br />
<br />
*'''Schritt 2:''' Entpacken und Ausführen des Tools.<br />
<br />
*'''Schritt 3:''' In der Liste der auf dem System registrierten Dateiendungen ''.jar'' suchen und markieren/selektieren<br />
<br />
*'''Schritt 4:''' Auf der rechten Seite den Button ''Erweiterung bearbeiten'' klicken<br />
<br />
*'''Schritt 5:''' Im Bearbeitungsdialog sollte nun bereits die Aktion ''open'' eingetragen sein. Dieser ist nun zu markieren/selektieren. Sollte die Aktion nicht existieren, muss sie angelegt werden. Dazu klicken wir auf ''Neue Aktion'', geben <br />
''open'' ein und bestätigen. Anschließend sollte der Bearbeitungsdialog so aussehen, wie im obigen Bild.<br />
<br />
*'''Schritt 6:''' Dieser Eintrag wird nun bearbeitet. Dazu klicken wir auf den Button ''Bearbeiten''.<br />
<br />
*'''Schritt 7:''' Im unteren Textfeld muss der richtige Pfad zur installierten JRE, sowie einige Platzhalter eingetragen sein bzw. werden. Wir prüfen also auf unserem System zunächst, ob der Pfad zur JRE stimmt. <br />
<br />
*'''Schritt 8:''' Der hier beispielhafte Pfad sollte so in etwa aussehen: <code>"C:\Program Files (x86)\Java\jre1.8.0_151\bin\javaw.exe" -jar "%1" %*</code><br />
<br />
*'''Schritt 9:''' Die Eingabe wird nun mit Klick auf ''Speichern'' übernommen. Auch im jetzt wieder sichtbaren Bearbeitungsdialog bestätigen wir unsere Änderungen mit ''Speichern''.<br />
<br />
*'''Schritt 10:''' Windows muss nun neu gestartet werden, damit die Änderungen in der Registry aktiviert werden. Anschließend sollten Jar-Programme wieder mit Doppelklick ausführbar sein.<br />
<br />
=Fehlermeldungen auf der Java-Console=<br />
<br />
=="Failed to load main class"==<br />
Wenn der Interpreter aus irgendeinem Grund die Start-Klasse ([[Klasse]] mit der main()-[[Methode]]) nicht laden kann, gibt er diese Fehlermeldung aus: "Failed to load main class"<br />
Die Ursachen dafür können recht vielfältig sein. Z.B. ein Fehler in der Manifest-Datei. (Siehe [https://wiki.byte-welt.net/wiki/Jar-Datei_mit_Doppelklick_nicht_ausf%C3%BChrbar%3F#Aufbau_und_Inhalt_von_META-INF Aufbau und Inhalt von META-INF])<br />
<br />
==NoClassDefFoundError==<br />
Wenn eine Klasse beim Kompilieren noch gefunden wurde, aber zur Laufzeit nicht mehr, kommt es zu einem {{JAPI|NoClassDefFoundError}}.<br />
<br />
==ClassNotFoundException==<br />
Dieser Fehler deutet auf ein Problem beim Laden einer Klasse hin. Sie z.B. tritt auf, wenn der {{JAPI|ClassLoader}} eine [[Klasse|Klassendatei]] nicht finden konnte. Nicht alle, in der [[JAR-Datei|Jar-Datei]] gespeicherten Klassen sind im Classpath.<br />
<br />
==NullPointerExecption==<br />
Auch oft anzutreffen, die [[NullPointerException]]. Dieser Ausnahmefehler ist oft auf der Console zu sehen, wenn bspw. eingebundene Resourcen, wie Bilder nicht gefunden wurden und daher Objekte nicht initialisiert werden konnten. Natürlich auch dann, wenn [[Referenz|Referenzen]] auf [[Objekt|Objekte]] noch auf <code>null</code> stehen.<br />
<br />
=Links=<br />
*[[Java-Programme starten - Möglichkeiten]]<br />
*[[Java-Programm nur einmal starten]]<br />
<br />
<br />
{{Fragen stellen}}<br />
<br />
[[Kategorie:Java]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=Jar-Datei_mit_Doppelklick_nicht_ausf%C3%BChrbar%3F&diff=7590Jar-Datei mit Doppelklick nicht ausführbar?2018-02-28T14:58:06Z<p>L-ectron-x: /* Aufbau und Inhalt von META-INF */</p>
<hr />
<div>Jar-Dateien ('''J'''ava '''Ar'''chive) sind prinzipiell im Zip-Format komprimierte Dateien, die aber durch spezielle Inhalte erweitert wurden. Per Doppelklick können von der [[JVM]] die in ihnen verpackten Java-Anwendungen ausgeführt werden.<br />
<br />
Du hast eine [[JAR-Datei]] erzeugt oder erhalten und diese lässt sich nicht per Doppelklick starten? Lösungen zu diesem Problem werden wir im Folgenden besprechen.<br />
<br />
=Anwendung oder Bibliothek?=<br />
Jar-Dateien fassen in sich geschlossene Anwendungen oder Bibliotheken (Library) zusammen. Während Bibliotheken nicht ausführbar sind und dazu dienen Funktionalität für ein Programm bereit zu stellen, sind Anwendungen, die in Jar-Dateien gespeichert sind durchaus per Doppelklick ausführbar. <br />
<br />
Ist die Jar-Datei nicht per Doppelklick ausführbar, liegt möglicherweise eine Bibliothek vor. Um das zu prüfen, sieht man sich kurzerhand den Inhalt der Jar-Datei mit einem Packprogramm an.<br />
<br />
'''Grundsätzlich müssen wir uns zu aller erst folgende Frage stellen:'''<br />
'''Ist es nur diese Jar-Datei, die ich nicht starten kann, oder sind alle Jar-Dateien betroffen?'''<br />
<br />
=Problem mit einer bestimmten Jar-Datei=<br />
<br />
==Jar-Datei in der Eingabeaufforderung/Terminal starten==<br />
Um zu testen, ob eine Jar-Datei zumindest fehlerfrei auf der Kommandozeile starten kann, wird folgender Befehl eingegeben:<br />
java -jar MeinJar.jar<br />
''MeinJar.jar'' bezeichnet dabei die auszuführende Jar-Datei. Zum Aufruf muss man sich bereits in dem Verzeichnis befinden, in welchem die Jar-Datei gespeichert wurde.<br />
<br />
Sollte es ein Problem mit der Jar-Datei geben, das die Ausführung verhindert, wird eine Fehlermeldung auf der Console/Eingabeaufforderung/Terminal ausgegeben.<br />
'''Der erste Schritt bei Problemen mit Jar-Dateien sollte also immer sein, zu sehen, ob bei der Ausführung Fehler auf der Console ausgegeben werden.'''<br />
<br />
==Aufbau und Inhalt von META-INF==<br />
Damit eine Jar-Datei ausführbar wird, enthält sie, wie bereits oben beschrieben, weitere spezielle Inhalte, die von der JVM ausgelesen und verarbeitet werden können. Im Wesentlichen handelt es sich dabei um das Verzeichnis ''META-INF'' bzw. um seinen Inhalt. In diesem Verzeichnis muss die [https://wiki.byte-welt.net/wiki/JAR-Datei#MANIFEST.MF Manifest-Datei] enthalten sein. Das Verzeichnis META-INF selbst liegt im Wurzelverzeichnis der Jar-Datei.<br />
<br />
[/]<br />
|__[META-INF]<br />
| |__ MANIFEST.MF<br />
|<br />
|__[mypackage]<br />
|__ Main.class<br />
<br />
Die Manifest-Datei enthält eine Reihe von Informationen, die der Interpreter für die Ausführung einer Java-Anwendung benötigt.<br />
<br />
In der Manifest-Datei müssen, damit eine Java-Anwendung per Jar-Datei ausführbar wird, mindestens folgende Angaben enthalten sein:<br />
<code=ini><br />
Manifest-Version: 1.0<br />
Main-Class: mypackage.Main<br />
<Leerzeile><br />
</code=ini><br />
Hinter Main-Class verbirgt sich die [[Klasse]], die die main()-[[Methode]] enthält und damit die Anwendung starten kann. Die Klasse heißt ''Main.class'' und liegt in diesem (obigen) Beispiel im [[Package]] ''mypackage''.<br />
'''Wichtig:''' Ohne eine Leerzeile am Ende der Manifest-Datei wird die Jar-Datei nicht per Mausklick ausführbar sein!<br />
Dieser Fehler tritt oft nur auf, wenn man die Jar-Datei manuell in der Eingabeaufforderung/Terminal erzeugt hat und die Leerzeile vergessen wurde. Eigentlich alle großen Java-[[IDE|IDEs]] können ausführbare Jar-Dateien erzeugen und werden diesen Part richtig machen.<br />
<br />
Wenn wir externe Bibliotheken, wie bspw. einen Datenbanktreiber oder ein [[LookAndFeel]] in unserem Programm benutzen, müssen diese entsprechend im Manifest unserer Jar-Datei eingebunden sein.<br />
<code=ini><br />
Class-Path: ./db/database.jar ./laf/look-and-feel.jar<br />
</code=ini><br />
Daher müsste die Zeile '''Class-Path:''' in der Manifest-Datei enthalten sein. In unserem Beispiel sind die eingebundenen Bibliotheken in verschiedenen Verzeichnissen relativ zu unserer Jar-Datei abgelegt.<br><br />
Der Datenbanktreiber liegt, ausgehend vom Verzeichnis unserer Jar-Datei, eine Verzeichnisebene tiefer, im Verzeichnis ''db''. Die Bibliothek des eingesetzten LookAndFeel liegt, ausgehend vom Verzeichnis unserer Jar-Datei, eine Verzeichnisebene tiefer, im Verzeichnis ''laf''.<br />
<br />
Wenn die Bibliotheken für den Java-[[Interpreter]] nicht in den in unserer Manifest-Datei bezeichneten Verzeichnissen zu finden sind, wird ein Fehler auf der Console ausgegeben werden und unsere Jar-Datei ist möglicherweise nicht ausführbar.<br />
<br />
=Generelles Problem mit Jar-Dateien=<br />
Es gibt in allen Betriebssystemen Konstellationen, die verhindern, dass eine Jar-Datei nach einem (Doppel-)Klick mit der Maus auf das Dateisymbol startet.<br />
<br />
Bei vielen Linux-Distributionen ist bspw. die Jar-Datei mit einem Archivierungsprogramm verknüpft, so dass der Inhalt der Jar-Datei angezeigt wird, statt dass sie gestartet wird.<br />
==Verknüpfung mit dem Java-Interpreter==<br />
Bei Einsatz bestimmter Komprimierungs- bzw. Archivierungsprogramme, wie bspw. [http://www.winrar.de/ WinRar] oder [http://www.7-zip.org/ 7Zip], kommt es gelegentlich aufgrund falscher Programmeinstellungen vor, dass diese Programme statt der gewünschten Jar-Datei beim Doppelklick auf eine Jar-Datei gestartet werden. Statt die Jar-Datei der JVM zu überlassen, leitet das [[Betriebssystem]] den Aufruf an das Packprogramm weiter, welches nun den Inhalt der Jar-Datei anzeigt.<br><br />
In den Einstellungen der Programme sollte nun zur Fehlerbehebung der Haken zum Öffnen von Jar-Dateien entfernt werden.<br />
<br />
Wenn man die Systemeinstellungen seines Linux-Systems nicht ändern möchte, kann man einen [[Programmstarter für Java-Programme anlegen]]. Der Doppelklick auf das angelegte Symbol startet dann das Java-Programm.<br />
<br />
===Interpreter-Typen===<br />
Es gibt zwei verschiedene Java-Interpreter. Zumindest unter [[Windows]]. Unter [[Linux]] gibt es nur einen [[JRE|Interpreter]], dem einerseits in der [[Kommandozeile]] auszuführende Java-Programme übergeben werden können. Andererseits kann man in Linux auch Einstellungen im System festmachen, die dann eine [[JAR-Datei|Jar-Datei]] mit Doppelklick, ohne Console starten können.<br />
<br />
Unter Windows wurden den Interpretern 2 Einsatzzwecke zugedacht. Will man ein Java-Programm auf der Kommandozeile starten, wird <code>java.exe</code> eingesetzt. Dieser Interpreter erzeugt Ausgaben auf der Java-Console bzw. auf der Kommandozeile, so dass bspw. [[Exception (Java)|Java-Fehlermeldungen]] oder Textausgaben, die im Programm mit <code>System.out.println()</code> erzeugt wurden, auf der Kommandozeile landen.<br />
<br />
Wenn man Java-Programme starten möchte, die eine Benutzeroberfläche ([[GUI]]) haben, (ohne dass sich eine Consolen öffnet) benutzt man unter [[Windows]] <code>javaw.exe</code>. Dieser Interpreter unterdrückt den Start der Kommandozeile.<br />
<br />
Für Programmstarts per Doppelklick sollte also die Verknüpfung in der Windows-Registry auf <code>javaw.exe</code> gesetzt sein. Im folgenden Kapitel gehen wir näher darauf ein.<br />
<br />
===Spezialfall Windows===<br />
[[Datei:ExtMan_Dateiendungen.PNG|mini|Schritt 3 - Dateiendung suchen]]<br />
[[Datei:ExtMan_Erweiterung_bearbeiten.PNG|mini|Schritt 5 - Erweiterung bearbeiten]]<br />
[[Datei:ExtMan_Pfad_zur_JRE.PNG|mini|Schritt 7 - Pfad zur JRE festlegen]]<br />
Unter Windows kann es passieren, dass die richtige Verknüpfung von JRE und Jar-Datei durch falsche Einstellungen oder versehentliches Neuverknüpfen zerstört wird. Jar-Dateien starten dann auch nicht mehr per Doppelklick. <br />
<br />
Das manuelle Beheben des Fehlers durch Eingriff in die Registry gestaltet sich inzwischen mit unter als nicht so trivial, weil mit jeder neuen Windows-Version sich die Struktur der Registry geändert hat. <br />
<br />
Mit Hilfe des kleinen Tools '''ExtMan''' lässt sich das Problem jedoch auf jedem Windows-System prüfen und ggf. reparieren.<br />
<br />
*'''Schritt 1:''' Herunterladen des Programms [https://www.google.de/search?q=extman ExtMan]<br />
<br />
*'''Schritt 2:''' Entpacken und Ausführen des Tools.<br />
<br />
*'''Schritt 3:''' In der Liste der auf dem System registrierten Dateiendungen ''.jar'' suchen und markieren/selektieren<br />
<br />
*'''Schritt 4:''' Auf der rechten Seite den Button ''Erweiterung bearbeiten'' klicken<br />
<br />
*'''Schritt 5:''' Im Bearbeitungsdialog sollte nun bereits die Aktion ''open'' eingetragen sein. Dieser ist nun zu markieren/selektieren. Sollte die Aktion nicht existieren, muss sie angelegt werden. Dazu klicken wir auf ''Neue Aktion'', geben <br />
''open'' ein und bestätigen. Anschließend sollte der Bearbeitungsdialog so aussehen, wie im obigen Bild.<br />
<br />
*'''Schritt 6:''' Dieser Eintrag wird nun bearbeitet. Dazu klicken wir auf den Button ''Bearbeiten''.<br />
<br />
*'''Schritt 7:''' Im unteren Textfeld muss der richtige Pfad zur installierten JRE, sowie einige Platzhalter eingetragen sein bzw. werden. Wir prüfen also auf unserem System zunächst, ob der Pfad zur JRE stimmt. <br />
<br />
*'''Schritt 8:''' Der hier beispielhafte Pfad sollte so in etwa aussehen: <code>"C:\Program Files (x86)\Java\jre1.8.0_151\bin\javaw.exe" -jar "%1" %*</code><br />
<br />
*'''Schritt 9:''' Die Eingabe wird nun mit Klick auf ''Speichern'' übernommen. Auch im jetzt wieder sichtbaren Bearbeitungsdialog bestätigen wir unsere Änderungen mit ''Speichern''.<br />
<br />
*'''Schritt 10:''' Windows muss nun neu gestartet werden, damit die Änderungen in der Registry aktiviert werden. Anschließend sollten Jar-Programme wieder mit Doppelklick ausführbar sein.<br />
<br />
=Fehlermeldungen auf der Java-Console=<br />
<br />
=="Failed to load main class"==<br />
Wenn der Interpreter aus irgendeinem Grund die Start-Klasse ([[Klasse]] mit der main()-[[Methode]]) nicht laden kann, gibt er diese Fehlermeldung aus: "Failed to load main class"<br />
Die Ursachen dafür können recht vielfältig sein. Z.B. ein Fehler in der Manifest-Datei. (Siehe [https://wiki.byte-welt.net/wiki/Jar-Datei_mit_Doppelklick_nicht_ausf%C3%BChrbar%3F#Aufbau_und_Inhalt_von_META-INF Aufbau und Inhalt von META-INF])<br />
<br />
==NoClassDefFoundError==<br />
Wenn eine Klasse beim Kompilieren noch gefunden wurde, aber zur Laufzeit nicht mehr, kommt es zu einem {{JAPI|NoClassDefFoundError}}.<br />
<br />
==ClassNotFoundException==<br />
Dieser Fehler deutet auf ein Problem beim Laden einer Klasse hin. Sie z.B. tritt auf, wenn der {{JAPI|ClassLoader}} eine [[Klasse|Klassendatei]] nicht finden konnte. Nicht alle, in der [[JAR-Datei|Jar-Datei]] gespeicherten Klassen sind im Classpath.<br />
<br />
==NullPointerExecption==<br />
Auch oft anzutreffen, die [[NullPointerException]]. Dieser Ausnahmefehler ist oft auf der Console zu sehen, wenn bspw. eingebundene Resourcen, wie Bilder nicht gefunden wurden und daher Objekte nicht initialisiert werden konnten. Natürlich auch dann, wenn [[Referenz|Referenzen]] auf [[Objekt|Objekte]] noch auf <code>null</code> stehen.<br />
<br />
=Links=<br />
*[[Java-Programme starten - Möglichkeiten]]<br />
*[[Java-Programm nur einmal starten]]<br />
<br />
<br />
{{Fragen stellen}}<br />
<br />
[[Kategorie:Java]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=Jar-Datei_mit_Doppelklick_nicht_ausf%C3%BChrbar%3F&diff=7589Jar-Datei mit Doppelklick nicht ausführbar?2018-02-28T14:57:15Z<p>L-ectron-x: /* Jar-Datei in der Eingabeaufforderung/Terminal starten */</p>
<hr />
<div>Jar-Dateien ('''J'''ava '''Ar'''chive) sind prinzipiell im Zip-Format komprimierte Dateien, die aber durch spezielle Inhalte erweitert wurden. Per Doppelklick können von der [[JVM]] die in ihnen verpackten Java-Anwendungen ausgeführt werden.<br />
<br />
Du hast eine [[JAR-Datei]] erzeugt oder erhalten und diese lässt sich nicht per Doppelklick starten? Lösungen zu diesem Problem werden wir im Folgenden besprechen.<br />
<br />
=Anwendung oder Bibliothek?=<br />
Jar-Dateien fassen in sich geschlossene Anwendungen oder Bibliotheken (Library) zusammen. Während Bibliotheken nicht ausführbar sind und dazu dienen Funktionalität für ein Programm bereit zu stellen, sind Anwendungen, die in Jar-Dateien gespeichert sind durchaus per Doppelklick ausführbar. <br />
<br />
Ist die Jar-Datei nicht per Doppelklick ausführbar, liegt möglicherweise eine Bibliothek vor. Um das zu prüfen, sieht man sich kurzerhand den Inhalt der Jar-Datei mit einem Packprogramm an.<br />
<br />
'''Grundsätzlich müssen wir uns zu aller erst folgende Frage stellen:'''<br />
'''Ist es nur diese Jar-Datei, die ich nicht starten kann, oder sind alle Jar-Dateien betroffen?'''<br />
<br />
=Problem mit einer bestimmten Jar-Datei=<br />
<br />
==Jar-Datei in der Eingabeaufforderung/Terminal starten==<br />
Um zu testen, ob eine Jar-Datei zumindest fehlerfrei auf der Kommandozeile starten kann, wird folgender Befehl eingegeben:<br />
java -jar MeinJar.jar<br />
''MeinJar.jar'' bezeichnet dabei die auszuführende Jar-Datei. Zum Aufruf muss man sich bereits in dem Verzeichnis befinden, in welchem die Jar-Datei gespeichert wurde.<br />
<br />
Sollte es ein Problem mit der Jar-Datei geben, das die Ausführung verhindert, wird eine Fehlermeldung auf der Console/Eingabeaufforderung/Terminal ausgegeben.<br />
'''Der erste Schritt bei Problemen mit Jar-Dateien sollte also immer sein, zu sehen, ob bei der Ausführung Fehler auf der Console ausgegeben werden.'''<br />
<br />
==Aufbau und Inhalt von META-INF==<br />
Damit eine Jar-Datei ausführbar wird, enthält sie, wie bereits oben beschrieben, weitere spezielle Inhalte, die von der JVM ausgelesen und verarbeitet werden können. Im Wesentlichen handelt es sich dabei um das Verzeichnis ''META-INF'' bzw. um seinen Inhalt. In diesem Verzeichnis muss die [https://wiki.byte-welt.net/wiki/JAR-Datei#MANIFEST.MF Manifest-Datei] enthalten sein. Das Verzeichnis META-INF selbst liegt im Wurzelverzeichnis der Jar-Datei.<br />
<br />
<code=ini><br />
[/]<br />
|__[META-INF]<br />
| |__ MANIFEST.MF<br />
|<br />
|__[mypackage]<br />
|__ Main.class<br />
</code=ini><br />
<br />
Die Manifest-Datei enthält eine Reihe von Informationen, die der Interpreter für die Ausführung einer Java-Anwendung benötigt.<br />
<br />
In der Manifest-Datei müssen, damit eine Java-Anwendung per Jar-Datei ausführbar wird, mindestens folgende Angaben enthalten sein:<br />
<code=ini><br />
Manifest-Version: 1.0<br />
Main-Class: mypackage.Main<br />
<Leerzeile><br />
</code=ini><br />
Hinter Main-Class verbirgt sich die [[Klasse]], die die main()-[[Methode]] enthält und damit die Anwendung starten kann. Die Klasse heißt ''Main.class'' und liegt in diesem (obigen) Beispiel im [[Package]] ''mypackage''.<br />
'''Wichtig:''' Ohne eine Leerzeile am Ende der Manifest-Datei wird die Jar-Datei nicht per Mausklick ausführbar sein!<br />
Dieser Fehler tritt oft nur auf, wenn man die Jar-Datei manuell in der Eingabeaufforderung/Terminal erzeugt hat und die Leerzeile vergessen wurde. Eigentlich alle großen Java-[[IDE|IDEs]] können ausführbare Jar-Dateien erzeugen und werden diesen Part richtig machen.<br />
<br />
Wenn wir externe Bibliotheken, wie bspw. einen Datenbanktreiber oder ein [[LookAndFeel]] in unserem Programm benutzen, müssen diese entsprechend im Manifest unserer Jar-Datei eingebunden sein.<br />
<code=ini><br />
Class-Path: ./db/database.jar ./laf/look-and-feel.jar<br />
</code=ini><br />
Daher müsste die Zeile '''Class-Path:''' in der Manifest-Datei enthalten sein. In unserem Beispiel sind die eingebundenen Bibliotheken in verschiedenen Verzeichnissen relativ zu unserer Jar-Datei abgelegt.<br><br />
Der Datenbanktreiber liegt, ausgehend vom Verzeichnis unserer Jar-Datei, eine Verzeichnisebene tiefer, im Verzeichnis ''db''. Die Bibliothek des eingesetzten LookAndFeel liegt, ausgehend vom Verzeichnis unserer Jar-Datei, eine Verzeichnisebene tiefer, im Verzeichnis ''laf''.<br />
<br />
Wenn die Bibliotheken für den Java-[[Interpreter]] nicht in den in unserer Manifest-Datei bezeichneten Verzeichnissen zu finden sind, wird ein Fehler auf der Console ausgegeben werden und unsere Jar-Datei ist möglicherweise nicht ausführbar.<br />
<br />
=Generelles Problem mit Jar-Dateien=<br />
Es gibt in allen Betriebssystemen Konstellationen, die verhindern, dass eine Jar-Datei nach einem (Doppel-)Klick mit der Maus auf das Dateisymbol startet.<br />
<br />
Bei vielen Linux-Distributionen ist bspw. die Jar-Datei mit einem Archivierungsprogramm verknüpft, so dass der Inhalt der Jar-Datei angezeigt wird, statt dass sie gestartet wird.<br />
==Verknüpfung mit dem Java-Interpreter==<br />
Bei Einsatz bestimmter Komprimierungs- bzw. Archivierungsprogramme, wie bspw. [http://www.winrar.de/ WinRar] oder [http://www.7-zip.org/ 7Zip], kommt es gelegentlich aufgrund falscher Programmeinstellungen vor, dass diese Programme statt der gewünschten Jar-Datei beim Doppelklick auf eine Jar-Datei gestartet werden. Statt die Jar-Datei der JVM zu überlassen, leitet das [[Betriebssystem]] den Aufruf an das Packprogramm weiter, welches nun den Inhalt der Jar-Datei anzeigt.<br><br />
In den Einstellungen der Programme sollte nun zur Fehlerbehebung der Haken zum Öffnen von Jar-Dateien entfernt werden.<br />
<br />
Wenn man die Systemeinstellungen seines Linux-Systems nicht ändern möchte, kann man einen [[Programmstarter für Java-Programme anlegen]]. Der Doppelklick auf das angelegte Symbol startet dann das Java-Programm.<br />
<br />
===Interpreter-Typen===<br />
Es gibt zwei verschiedene Java-Interpreter. Zumindest unter [[Windows]]. Unter [[Linux]] gibt es nur einen [[JRE|Interpreter]], dem einerseits in der [[Kommandozeile]] auszuführende Java-Programme übergeben werden können. Andererseits kann man in Linux auch Einstellungen im System festmachen, die dann eine [[JAR-Datei|Jar-Datei]] mit Doppelklick, ohne Console starten können.<br />
<br />
Unter Windows wurden den Interpretern 2 Einsatzzwecke zugedacht. Will man ein Java-Programm auf der Kommandozeile starten, wird <code>java.exe</code> eingesetzt. Dieser Interpreter erzeugt Ausgaben auf der Java-Console bzw. auf der Kommandozeile, so dass bspw. [[Exception (Java)|Java-Fehlermeldungen]] oder Textausgaben, die im Programm mit <code>System.out.println()</code> erzeugt wurden, auf der Kommandozeile landen.<br />
<br />
Wenn man Java-Programme starten möchte, die eine Benutzeroberfläche ([[GUI]]) haben, (ohne dass sich eine Consolen öffnet) benutzt man unter [[Windows]] <code>javaw.exe</code>. Dieser Interpreter unterdrückt den Start der Kommandozeile.<br />
<br />
Für Programmstarts per Doppelklick sollte also die Verknüpfung in der Windows-Registry auf <code>javaw.exe</code> gesetzt sein. Im folgenden Kapitel gehen wir näher darauf ein.<br />
<br />
===Spezialfall Windows===<br />
[[Datei:ExtMan_Dateiendungen.PNG|mini|Schritt 3 - Dateiendung suchen]]<br />
[[Datei:ExtMan_Erweiterung_bearbeiten.PNG|mini|Schritt 5 - Erweiterung bearbeiten]]<br />
[[Datei:ExtMan_Pfad_zur_JRE.PNG|mini|Schritt 7 - Pfad zur JRE festlegen]]<br />
Unter Windows kann es passieren, dass die richtige Verknüpfung von JRE und Jar-Datei durch falsche Einstellungen oder versehentliches Neuverknüpfen zerstört wird. Jar-Dateien starten dann auch nicht mehr per Doppelklick. <br />
<br />
Das manuelle Beheben des Fehlers durch Eingriff in die Registry gestaltet sich inzwischen mit unter als nicht so trivial, weil mit jeder neuen Windows-Version sich die Struktur der Registry geändert hat. <br />
<br />
Mit Hilfe des kleinen Tools '''ExtMan''' lässt sich das Problem jedoch auf jedem Windows-System prüfen und ggf. reparieren.<br />
<br />
*'''Schritt 1:''' Herunterladen des Programms [https://www.google.de/search?q=extman ExtMan]<br />
<br />
*'''Schritt 2:''' Entpacken und Ausführen des Tools.<br />
<br />
*'''Schritt 3:''' In der Liste der auf dem System registrierten Dateiendungen ''.jar'' suchen und markieren/selektieren<br />
<br />
*'''Schritt 4:''' Auf der rechten Seite den Button ''Erweiterung bearbeiten'' klicken<br />
<br />
*'''Schritt 5:''' Im Bearbeitungsdialog sollte nun bereits die Aktion ''open'' eingetragen sein. Dieser ist nun zu markieren/selektieren. Sollte die Aktion nicht existieren, muss sie angelegt werden. Dazu klicken wir auf ''Neue Aktion'', geben <br />
''open'' ein und bestätigen. Anschließend sollte der Bearbeitungsdialog so aussehen, wie im obigen Bild.<br />
<br />
*'''Schritt 6:''' Dieser Eintrag wird nun bearbeitet. Dazu klicken wir auf den Button ''Bearbeiten''.<br />
<br />
*'''Schritt 7:''' Im unteren Textfeld muss der richtige Pfad zur installierten JRE, sowie einige Platzhalter eingetragen sein bzw. werden. Wir prüfen also auf unserem System zunächst, ob der Pfad zur JRE stimmt. <br />
<br />
*'''Schritt 8:''' Der hier beispielhafte Pfad sollte so in etwa aussehen: <code>"C:\Program Files (x86)\Java\jre1.8.0_151\bin\javaw.exe" -jar "%1" %*</code><br />
<br />
*'''Schritt 9:''' Die Eingabe wird nun mit Klick auf ''Speichern'' übernommen. Auch im jetzt wieder sichtbaren Bearbeitungsdialog bestätigen wir unsere Änderungen mit ''Speichern''.<br />
<br />
*'''Schritt 10:''' Windows muss nun neu gestartet werden, damit die Änderungen in der Registry aktiviert werden. Anschließend sollten Jar-Programme wieder mit Doppelklick ausführbar sein.<br />
<br />
=Fehlermeldungen auf der Java-Console=<br />
<br />
=="Failed to load main class"==<br />
Wenn der Interpreter aus irgendeinem Grund die Start-Klasse ([[Klasse]] mit der main()-[[Methode]]) nicht laden kann, gibt er diese Fehlermeldung aus: "Failed to load main class"<br />
Die Ursachen dafür können recht vielfältig sein. Z.B. ein Fehler in der Manifest-Datei. (Siehe [https://wiki.byte-welt.net/wiki/Jar-Datei_mit_Doppelklick_nicht_ausf%C3%BChrbar%3F#Aufbau_und_Inhalt_von_META-INF Aufbau und Inhalt von META-INF])<br />
<br />
==NoClassDefFoundError==<br />
Wenn eine Klasse beim Kompilieren noch gefunden wurde, aber zur Laufzeit nicht mehr, kommt es zu einem {{JAPI|NoClassDefFoundError}}.<br />
<br />
==ClassNotFoundException==<br />
Dieser Fehler deutet auf ein Problem beim Laden einer Klasse hin. Sie z.B. tritt auf, wenn der {{JAPI|ClassLoader}} eine [[Klasse|Klassendatei]] nicht finden konnte. Nicht alle, in der [[JAR-Datei|Jar-Datei]] gespeicherten Klassen sind im Classpath.<br />
<br />
==NullPointerExecption==<br />
Auch oft anzutreffen, die [[NullPointerException]]. Dieser Ausnahmefehler ist oft auf der Console zu sehen, wenn bspw. eingebundene Resourcen, wie Bilder nicht gefunden wurden und daher Objekte nicht initialisiert werden konnten. Natürlich auch dann, wenn [[Referenz|Referenzen]] auf [[Objekt|Objekte]] noch auf <code>null</code> stehen.<br />
<br />
=Links=<br />
*[[Java-Programme starten - Möglichkeiten]]<br />
*[[Java-Programm nur einmal starten]]<br />
<br />
<br />
{{Fragen stellen}}<br />
<br />
[[Kategorie:Java]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=Hauptseite&diff=7588Hauptseite2018-02-28T14:46:45Z<p>L-ectron-x: </p>
<hr />
<div><!-- Willkommen --><br />
<center><table cellpadding="0px" cellspacing="0px" style="margin-bottom:50px"><br />
<tr><br />
<td align="center" style="border:1px solid #2C4051; padding:10px; font-weight:bold; color:white; background-color:#2C4051">Willkommen im Byte-Welt-Wiki</td><br />
</tr><br />
<tr><br />
<td valign="top" style="border:1px solid #2C4051; width:100%; border-top:0px; padding:10px; text-align:left">Das Byte-Welt-Wiki ist ein Projekt zum Aufbau einer IT-Enzyklopädie aus freien Inhalten. Jeder kann mit seinem Wissen beitragen und somit helfen, Wissen zu vermitteln und zu bewahren. Gute Autorinnen und Autoren sind stets willkommen, um dieses Projekt schrittweise aufzubauen, zu erweitern und zu verbessern.<br />
Um am Byte-Welt-Wiki mitzuwirken, ist aus Spamschutzgründen eine [http://forum.byte-welt.net/register.php Registrierung] im [http://forum.byte-welt.net/ Byte-Welt-Forum] erforderlich. Mit den persönlichen Zugangsdaten des Forums dürfen dann auch Beiträge im Wiki erstellt oder geändert werden.<br />
</td><br />
</tr><br />
</table></center><br />
<br />
<!-- Autor des Monats --><!-- Tipp --><!-- Newsflash --><br />
<table cellpadding="0px" cellspacing="0px" style="margin-bottom:50px"><br />
<tr><br />
<!--<td align="center" style="border:1px solid #2C4051; padding:10px; font-weight:bold; background-color:#2C4051">Autor/-in des Monats</td><br />
<td></td>--><br />
<td align="center" style="border:1px solid #2C4051; padding:10px; font-weight:bold; color:white; background-color:#2C4051">Tipp</td><br />
<td></td><br />
<td align="center" style="border:1px solid #2C4051; padding:10px; font-weight:bold; color:white; background-color:#2C4051">Newsflash</td><br />
</tr><br />
<tr><br />
<!--<td style="border-left:1px solid #2C4051; border-right:1px solid #2C4051; width:30%; text-align:left"><table><tr><td>[[Bild: Pokal.png]]</td><td><br/>'''I'''n diesem Monat wurden folgende Autoren für gute Arbeit im Wiki ausgezeichnet:</td></tr></table></td><br />
<td></td>--><br />
<td style="border-left:1px solid #000; border-right:1px solid #000; width:30%; text-align:left"><table><tr><td>[[Bild: Gluehbirne.png]]</td><td><br/> '''F'''ür das schnelle Navigieren im Wiki bitte das [[Inhalt|Inhaltsverzeichnis]] nutzen.</td></tr></table></td><br />
<td></td><br />
<td style="border-left:1px solid #000; border-right:1px solid #000; width:30%; text-align:left"><table><tr><td>[[Bild: Newsflash.png]]</td><td>'''News aus dem Byte-Welt Themenbereich'''</td></tr></table></td><br />
<tr><br />
<!--<td valign="top" style="border:1px solid #000; width:30%; border-top:0px; padding:5px"><br/><br/>[[Benutzer:AndreUhres|AndreUhres]], [[Benutzer:SeannWilliamScott|SeannWilliamScott]]<br/>mehr dazu [[Auszeichnungen| hier..]]<br />
</td><br />
<td style="width:5%"></td>--><br />
<td valign="top" style="border:1px solid #2C4051; width:30%; border-top:0px; padding:10px"><br />
<table align="center" style="margin-top:20px"><br />
<tr><br />
<td>{{Neuer Artikel}}</td><br />
</tr><br />
</table><br />
</td><br />
<td style="width:5%"></td><br />
<td valign="top" style="border:1px solid #2C4051; width:30%; border-top:0px; padding:10px"><br />
Java 9.0.4 veröffentlicht! [http://java.sun.com/javase/downloads/index.jsp]<br />
Java 8 Update 162/162 veröffentlicht! [http://java.sun.com/javase/downloads/index.jsp]<br />
LibreOffice 6.0 [http://de.libreoffice.org/] veröffentlicht<br />
NetBeans 8.2 erschienen! [http://netbeans.org/downloads/index.html]<br />
Eclipse 4.6.2 (Neon) erschienen! [http://www.eclipse.org/downloads/]<br />
Linux Mint 18.3 "Sylvia" erschienen! [http://www.linuxmint.com/]<br />
Ubuntu 17.10 erschienen! [http://www.ubuntu.com]<br />
Debian 9.0 "Stretch" erschienen! [http://www.debian.com/]<br />
</td><br />
</tr><br />
</table><br />
<br />
<!-- Zufallsartikeln Nr1 + 2 --><br />
<table cellpadding="0px" cellspacing="0px"><br />
<tr><br />
<td align="center" style="border:1px solid #2C4051; padding:10px; font-weight:bold; color:white; background-color:#2C4051">Kategorien</td><br />
</tr><br />
<tr><br />
<td valign="top" style="border:1px solid #2C4051; width:48%; border-top:0px; padding:10px"><br />
<tagcloud><br />
min_count=5<br />
</tagcloud><br />
</td><br />
</tr><br />
</table></div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=Hauptseite&diff=7587Hauptseite2018-02-28T14:46:04Z<p>L-ectron-x: </p>
<hr />
<div><!-- Willkommen --><br />
<center><table cellpadding="0px" cellspacing="0px" style="margin-bottom:50px"><br />
<tr><br />
<td align="center" style="border:1px solid #2C4051; padding:10px; font-weight:bold; color:white; background-color:#2C4051">Willkommen im Byte-Welt-Wiki</td><br />
</tr><br />
<tr><br />
<td valign="top" style="border:1px solid #2C4051; width:100%; border-top:0px; padding:10px; text-align:left">Das Byte-Welt-Wiki ist ein Projekt zum Aufbau einer IT-Enzyklopädie aus freien Inhalten. Jeder kann mit seinem Wissen beitragen und somit helfen, Wissen zu vermitteln und zu bewahren. Gute Autorinnen und Autoren sind stets willkommen, um dieses Projekt schrittweise aufzubauen, zu erweitern und zu verbessern.<br />
Um am Byte-Welt-Wiki mitzuwirken, ist aus Spamschutzgründen eine [http://forum.byte-welt.net/register.php Registrierung] im [http://forum.byte-welt.net/ Byte-Welt-Forum] erforderlich. Mit den persönlichen Zugangsdaten des Forums dürfen dann auch Beiträge im Wiki erstellt oder geändert werden.<br />
</td><br />
</tr><br />
</table></center><br />
<br />
<!-- Autor des Monats --><!-- Tipp --><!-- Newsflash --><br />
<table cellpadding="0px" cellspacing="0px" style="margin-bottom:50px"><br />
<tr><br />
<!--<td align="center" style="border:1px solid #2C4051; padding:10px; font-weight:bold; background-color:#2C4051">Autor/-in des Monats</td><br />
<td></td>--><br />
<td align="center" style="border:1px solid #2C4051; padding:10px; font-weight:bold; color:white; background-color:#2C4051">Tipp</td><br />
<td></td><br />
<td align="center" style="border:1px solid #2C4051; padding:10px; font-weight:bold; color:white; background-color:#2C4051">Newsflash</td><br />
</tr><br />
<tr><br />
<!--<td style="border-left:1px solid #2C4051; border-right:1px solid #2C4051; width:30%; text-align:left"><table><tr><td>[[Bild: Pokal.png]]</td><td><br/>'''I'''n diesem Monat wurden folgende Autoren für gute Arbeit im Wiki ausgezeichnet:</td></tr></table></td><br />
<td></td>--><br />
<td style="border-left:1px solid #000; border-right:1px solid #000; width:30%; text-align:left"><table><tr><td>[[Bild: Gluehbirne.png]]</td><td><br/> '''F'''ür das schnelle Navigieren im Wiki bitte das [[Inhalt|Inhaltsverzeichnis]] nutzen.</td></tr></table></td><br />
<td></td><br />
<td style="border-left:1px solid #000; border-right:1px solid #000; width:30%; text-align:left"><table><tr><td>[[Bild: Newsflash.png]]</td><td>'''News aus dem Byte-Welt Themenbereich'''</td></tr></table></td><br />
<tr><br />
<!--<td valign="top" style="border:1px solid #000; width:30%; border-top:0px; padding:5px"><br/><br/>[[Benutzer:AndreUhres|AndreUhres]], [[Benutzer:SeannWilliamScott|SeannWilliamScott]]<br/>mehr dazu [[Auszeichnungen| hier..]]<br />
</td><br />
<td style="width:5%"></td>--><br />
<td valign="top" style="border:1px solid #2C4051; width:30%; border-top:0px; padding:10px"><br />
<table align="center" style="margin-top:20px"><br />
<tr><br />
<td>{{Neuer Artikel}}</td><br />
</tr><br />
</table><br />
</td><br />
<td style="width:5%"></td><br />
<td valign="top" style="border:1px solid #2C4051; width:30%; border-top:0px; padding:10px"><br />
Java 9.0.4 veröffentlicht! [http://java.sun.com/javase/downloads/index.jsp]<br />
Java 8 Update 162/162 veröffentlicht! [http://java.sun.com/javase/downloads/index.jsp]<br />
LibreOffice 6.0 [http://de.libreoffice.org/] veröffentlicht<br />
NetBeans 8.2 erschienen! [http://netbeans.org/downloads/index.html]<br />
Eclipse 4.6.2 (Neon) erschienen! [http://www.eclipse.org/downloads/]<br />
Linux Mint 18.3 "Sylvia" erschienen! [http://www.linuxmint.com/]<br />
Ubuntu 17.10 erschienen! [http://www.ubuntu.com]<br />
Debian 9.0 "Stretch" erschienen! [http://www.debian.com/]<br />
</td><br />
</tr><br />
</table><br />
<br />
<!-- Zufallsartikeln Nr1 + 2<br />
<table cellpadding="0px" cellspacing="0px"><br />
<tr><br />
<td align="center" style="border:1px solid #2C4051; padding:10px; font-weight:bold; color:white; background-color:#2C4051">Kategorien</td><br />
</tr><br />
<tr><br />
<td valign="top" style="border:1px solid #2C4051; width:48%; border-top:0px; padding:10px"><br />
<tagcloud><br />
min_count=5<br />
</tagcloud><br />
</td><br />
</tr><br />
</table> --></div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=4_Grundrechenarten_auf_der_Kommandozeile&diff=75864 Grundrechenarten auf der Kommandozeile2018-02-27T15:23:15Z<p>L-ectron-x: </p>
<hr />
<div>In diesem Code-Beispiel bauen wir uns einen Rechner für die Kommandozeile.<br />
<br />
Die hier vorgestellte Klasse CommandCalc berechnet das Ergebnis einer Grundrechenart-Operation mit zwei Operanden. Dabei erwartet sie die Teile der Rechenaufgabe als Argumente beim Start des Programms.<br />
<br />
'''Beispiel:'''<br />
java CommandCalc 3,2 x 5,8<br />
Das Beispiel startet eine Multiplikation. Üblicherweise wird bei einer Multiplikation das Sternchen als Operator eingesetzt. Da das Sternchen aber auf den Kommandozeilen der bekannten Betriebssysteme bereits eine Wildcard-Funktion inne hat, benutzen wir ersatzweise das <code>x</code>.<br />
<br />
<code=java><br />
import static java.util.Locale.GERMANY;<br />
<br />
/**<br />
* CommandCalc berechnet das Ergebnis einer Grundrechenart-Operation mit zwei Operanden.<br />
* <br />
* @author Gernot Segieth<br />
*/<br />
public class CommandCalc {<br />
public static void main(String[] args) {<br />
if(args.length == 3 && checkArgs(args)) {<br />
System.out.print(args[0] +" "+ args[1] +" "+ args[2] +" = ");<br />
switch(args[1]) {<br />
case "+":<br />
System.out.format(GERMANY, "%f%n", addition(parse(args[0]), parse(args[2])));<br />
break;<br />
case "-":<br />
System.out.format(GERMANY, "%f%n", subtraction(parse(args[0]), parse(args[2])));<br />
break;<br />
case "x":<br />
System.out.format(GERMANY, "%f%n", multiplication(parse(args[0]), parse(args[2])));<br />
break;<br />
case "/":<br />
System.out.format(GERMANY, "%f%n", division(parse(args[0]), parse(args[2])));<br />
break;<br />
default:<br />
System.out.println("Unzulässiger Operator!");<br />
}<br />
System.out.println();<br />
} else {<br />
System.out.println("CommandCalc, 2015 - Gernot Segieth");<br />
System.out.println("Zulässige Operatoren: + - x /");<br />
System.out.println("Verwendungsbeispiel:\njava CommandCalc 5 + 8");<br />
}<br />
}<br />
<br />
private static boolean checkArgs(String[] args) {<br />
/*<br />
* Regex Erklärung:<br />
* - die zahl hat optional an erster Stelle ein negatives Vorzeichen<br />
* - darauf folgt mindestens eine Ziffer<br />
* - optional: (die Zahl darf einen Punkt oder Komma enthalten<br />
* - nach dem Punkt oder Komma endet die Zahl mit mindestens einer weiteren Ziffer)<br />
*/<br />
String pattern = "^[-]?\\d+([.,]\\d+)?$";<br />
return args[0].matches(pattern) && args[2].matches(pattern);<br />
}<br />
<br />
private static double parse(String arg) {<br />
return Double.parseDouble(arg.replace(',', '.'));<br />
}<br />
<br />
private static double addition(double arg1, double arg2) {<br />
return arg1 + arg2;<br />
}<br />
<br />
private static double subtraction(double arg1, double arg2) {<br />
return arg1 - arg2;<br />
}<br />
<br />
private static double multiplication(double arg1, double arg2) {<br />
return arg1 * arg2;<br />
}<br />
<br />
private static double division(double arg1, double arg2) {<br />
return arg1 / arg2;<br />
}<br />
}<br />
</code=java><br />
<br />
[[Kategorie:Java]]<br />
[[Kategorie:Java Grundlagen]]<br />
[[Kategorie:Java-Codeschnipsel]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=4_Grundrechenarten_auf_der_Kommandozeile&diff=75854 Grundrechenarten auf der Kommandozeile2018-02-27T15:00:17Z<p>L-ectron-x: </p>
<hr />
<div>In diesem Code-Beispiel bauen wir uns einen Rechner für die Kommandozeile.<br />
<br />
<code=java><br />
import static java.util.Locale.GERMANY;<br />
<br />
/**<br />
* CommandCalc berechnet das Ergebnis einer Rechenoperation mit zwei Operanden.<br />
* <br />
* @author Gernot Segieth<br />
*/<br />
public class CommandCalc {<br />
public static void main(String[] args) {<br />
if(args.length == 3 && checkArgs(args)) {<br />
System.out.print(args[0] +" "+ args[1] +" "+ args[2] +" = ");<br />
switch(args[1]) {<br />
case "+":<br />
System.out.format(GERMANY, "%f%n", addition(parse(args[0]), parse(args[2])));<br />
break;<br />
case "-":<br />
System.out.format(GERMANY, "%f%n", subtraction(parse(args[0]), parse(args[2])));<br />
break;<br />
case "x":<br />
System.out.format(GERMANY, "%f%n", multiplication(parse(args[0]), parse(args[2])));<br />
break;<br />
case "/":<br />
System.out.format(GERMANY, "%f%n", division(parse(args[0]), parse(args[2])));<br />
break;<br />
default:<br />
System.out.println("Unzulässiger Operator!");<br />
}<br />
System.out.println();<br />
} else {<br />
System.out.println("CommandCalc, 2015 - Gernot Segieth");<br />
System.out.println("Zulässige Operatoren: + - x /");<br />
System.out.println("Verwendungsbeispiel:\njava CommandCalc 5 + 8");<br />
}<br />
}<br />
<br />
private static boolean checkArgs(String[] args) {<br />
/*<br />
* Regex Erklärung:<br />
* - die zahl hat optional an erster Stelle ein negatives Vorzeichen<br />
* - darauf folgt mindestens eine Ziffer<br />
* - optional: (die Zahl darf einen Punkt oder Komma enthalten<br />
* - nach dem Punkt oder Komma endet die Zahl mit mindestens einer weiteren Ziffer)<br />
*/<br />
String pattern = "^[-]?\\d+([.,]\\d+)?$";<br />
return args[0].matches(pattern) && args[2].matches(pattern);<br />
}<br />
<br />
private static double parse(String arg) {<br />
return Double.parseDouble(arg.replace(',', '.'));<br />
}<br />
<br />
private static double addition(double arg1, double arg2) {<br />
return arg1 + arg2;<br />
}<br />
<br />
private static double subtraction(double arg1, double arg2) {<br />
return arg1 - arg2;<br />
}<br />
<br />
private static double multiplication(double arg1, double arg2) {<br />
return arg1 * arg2;<br />
}<br />
<br />
private static double division(double arg1, double arg2) {<br />
return arg1 / arg2;<br />
}<br />
}<br />
</code=java><br />
<br />
[[Kategorie:Java]]<br />
[[Kategorie:Java Grundlagen]]<br />
[[Kategorie:Java-Codeschnipsel]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=4_Grundrechenarten_auf_der_Kommandozeile&diff=75844 Grundrechenarten auf der Kommandozeile2018-02-27T14:59:56Z<p>L-ectron-x: </p>
<hr />
<div>In diesem Code-Beispiel bauen wir uns einen Rechner für die Kommandozeile.<br />
<br />
<code=java><br />
import static java.util.Locale.GERMANY;<br />
<br />
/**<br />
* CommandCalc berechnet das Ergebnis einer Rechenoperation mit zwei Operanden.<br />
* <br />
* @author Gernot Segieth<br />
*/<br />
public class CommandCalc {<br />
public static void main(String[] args) {<br />
if(args.length == 3 && checkArgs(args)) {<br />
System.out.print(args[0] +" "+ args[1] +" "+ args[2] +" = ");<br />
switch(args[1]) {<br />
case "+":<br />
System.out.format(GERMANY, "%f%n", addition(parse(args[0]), parse(args[2])));<br />
break;<br />
case "-":<br />
System.out.format(GERMANY, "%f%n", subtraction(parse(args[0]), parse(args[2])));<br />
break;<br />
case "x":<br />
System.out.format(GERMANY, "%f%n", multiplication(parse(args[0]), parse(args[2])));<br />
break;<br />
case "/":<br />
System.out.format(GERMANY, "%f%n", division(parse(args[0]), parse(args[2])));<br />
break;<br />
default:<br />
System.out.println("Unzulässiger Operator!");<br />
}<br />
System.out.println();<br />
} else {<br />
System.out.println("CommandCalc, 2015 - Gernot Segieth");<br />
System.out.println("Zulässige Operatoren: + - x /");<br />
System.out.println("Verwendungsbeispiel:\njava CommandCalc 5 + 8");<br />
}<br />
}<br />
<br />
private static boolean checkArgs(String[] args) {<br />
/*<br />
* Regex Erklärung:<br />
* - die zahl hat optional an erster Stelle ein negatives Vorzeichen<br />
* - darauf folgt mindestens eine Ziffer<br />
* - optional: (die Zahl darf einen Punkt oder Komma enthalten<br />
* - nach dem Punkt oder Komma endet die Zahl mit mindestens einer weiteren Ziffer)<br />
*/<br />
String pattern = "^[-]?\\d+([.,]\\d+)?$";<br />
return args[0].matches(pattern) && args[2].matches(pattern);<br />
}<br />
<br />
private static double parse(String arg) {<br />
return Double.parseDouble(arg.replace(',', '.'));<br />
}<br />
<br />
private static double addition(double arg1, double arg2) {<br />
return arg1 + arg2;<br />
}<br />
<br />
private static double subtraction(double arg1, double arg2) {<br />
return arg1 - arg2;<br />
}<br />
<br />
private static double multiplication(double arg1, double arg2) {<br />
return arg1 * arg2;<br />
}<br />
<br />
private static double division(double arg1, double arg2) {<br />
return arg1 / arg2;<br />
}<br />
}<br />
</code=java><br />
<br />
[[Kategorie:Java]]<br />
[[Kategorie:Java Grundlagen]]<br />
[[Kategorie:Java Codeschnipsel]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=4_Grundrechenarten_auf_der_Kommandozeile&diff=75834 Grundrechenarten auf der Kommandozeile2018-02-27T14:57:22Z<p>L-ectron-x: Die Seite wurde neu angelegt: „In diesem Code-Beispiel bauen wir uns einen Rechner für die Kommandozeile. <code=java> import static java.util.Locale.GERMANY; /** * CommandCalc berechnet…“</p>
<hr />
<div>In diesem Code-Beispiel bauen wir uns einen Rechner für die Kommandozeile.<br />
<br />
<code=java><br />
import static java.util.Locale.GERMANY;<br />
<br />
/**<br />
* CommandCalc berechnet das Ergebnis einer Rechenoperation mit zwei Operanden.<br />
* <br />
* @author Gernot Segieth<br />
*/<br />
public class CommandCalc {<br />
public static void main(String[] args) {<br />
if(args.length == 3 && checkArgs(args)) {<br />
System.out.print(args[0] +" "+ args[1] +" "+ args[2] +" = ");<br />
switch(args[1]) {<br />
case "+":<br />
System.out.format(GERMANY, "%f%n", addition(parse(args[0]), parse(args[2])));<br />
break;<br />
case "-":<br />
System.out.format(GERMANY, "%f%n", subtraction(parse(args[0]), parse(args[2])));<br />
break;<br />
case "x":<br />
System.out.format(GERMANY, "%f%n", multiplication(parse(args[0]), parse(args[2])));<br />
break;<br />
case "/":<br />
System.out.format(GERMANY, "%f%n", division(parse(args[0]), parse(args[2])));<br />
break;<br />
default:<br />
System.out.println("Unzulässiger Operator!");<br />
}<br />
System.out.println();<br />
} else {<br />
System.out.println("CommandCalc, 2015 - Gernot Segieth");<br />
System.out.println("Zulässige Operatoren: + - x /");<br />
System.out.println("Verwendungsbeispiel:\njava CommandCalc 5 + 8");<br />
}<br />
}<br />
<br />
private static boolean checkArgs(String[] args) {<br />
/*<br />
* Regex Erklärung:<br />
* - die zahl hat optional an erster Stelle ein negatives Vorzeichen<br />
* - darauf folgt mindestens eine Ziffer<br />
* - optional: (die Zahl darf einen Punkt oder Komma enthalten<br />
* - nach dem Punkt oder Komma endet die Zahl mit mindestens einer weiteren Ziffer)<br />
*/<br />
String pattern = "^[-]?\\d+([.,]\\d+)?$";<br />
return args[0].matches(pattern) && args[2].matches(pattern);<br />
}<br />
<br />
private static double parse(String arg) {<br />
return Double.parseDouble(arg.replace(',', '.'));<br />
}<br />
<br />
private static double addition(double arg1, double arg2) {<br />
return arg1 + arg2;<br />
}<br />
<br />
private static double subtraction(double arg1, double arg2) {<br />
return arg1 - arg2;<br />
}<br />
<br />
private static double multiplication(double arg1, double arg2) {<br />
return arg1 * arg2;<br />
}<br />
<br />
private static double division(double arg1, double arg2) {<br />
return arg1 / arg2;<br />
}<br />
}<br />
</code=java></div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=VirtualBox&diff=7582VirtualBox2018-02-25T10:31:05Z<p>L-ectron-x: /* Am Beispiel Microsoft Windows XP */</p>
<hr />
<div>{{Unvollständig}}<br />
<br />
[[Bild:VirtualBox (Windows).png|thumb|350px|VirtualBox unter Windows]]<br />
<br />
=Installation=<br />
==Unter Windows==<br />
<br />
<br />
==Unter Linux (Debian/Ubuntu)==<br />
Das Programm kann mit folgendem Konsolenbefehl installiert werden:<br/><br />
'''Terminal/Konsole: '''([http://wiki.byte-welt.de/wiki/Software_installieren_(Ubuntu) Paket installieren])<br/><br />
<code=text>sudo apt-get install virtualbox</code=text><br />
Unter Umständen kann es in älteren [[Ubuntu]]-Versionen zu Fehlermeldungen kommen, die auf das fehlende [[Paket]] libxalan110 verweisen.<br />
Dann muss noch zuerst das Paket libxalan110 installiert werden.<br/><br />
'''Terminal/Konsole: '''(Paket installieren)<br/><br />
<code=text>sudo apt-get install libxalan110</code=text><br />
Dabei werden zunächst benötigte Pakete heruntergeladen und gleich darauf installiert.<br/><br />
[http://wiki.byte-welt.de/wiki/VirtualBox_(Ubuntu)#Inbetriebnahme Weiter geht's bei Inbetriebnahme].<br />
<br />
=Manueller Download=<br />
'''Folgende Variante beschreibt die Installation nach manuellem Download der aktuellen Version'''<br />
*Zunächst sollte die aktuellste VirtualBox Version für Linux [http://www.virtualbox.org/wiki/Downloads hier] heruntergeladen werden.<br/><br />
*Das Paket ist im Format .deb verfügbar, das heißt es kann einfach mit Mausdoppelklick installiert werden.<br/><br />
<br />
=Inbetriebnahme=<br />
Um möglichst viele Funktionen von VirtualBox nutzen zu können, sollten zur Inbetriebnahme einige Arbeiten nach der Installation durchgeführt werden.<br />
<br />
==Linux==<br />
'''Anpassungen nach der Installation'''<br />
*Wenn VirtualBox fehlerfrei installiert wurde, müssen anschließend alle Benutzer, die VirtualBox benutzen dürfen zur Gruppe '''vboxusers''' hinzugefügt werden.<br />
'''Terminal/Konsole:''' (Benutzer einer Gruppe hinzufügen)<br/><br />
<code=text>sudo adduser benutzerkonto vboxusers</code=text><br />
ODER auch<br />
<code=text>sudo usermod -aG vboxusers $USER</code=text><br />
<br />
'''Wichtig! Wenn der aktuelle Benutzer bzw. der Benutzer, der mit VirtualBox arbeiten soll nicht der Benutzergruppe '''''vboxusers''''' hinzugefügt wird, können z.B. keine USB-Geräte in den virtuellen Betriebssystemen eingebunden werden.'''<br />
<br />
*Anschließend muss eine Ab- und Wiederanmeldung am System erfolgen.<br />
*VirtualBox ist nun fertig eingerichtet und kann über Anwendungen -> Systemwerkzeuge oder in der Konsole mit dem Befehl '''virtualbox''' gestartet werden.<br />
<br />
=Konfiguration=<br />
<br />
=Installation eines virtuellen Betriebssystems=<br />
==Am Beispiel Microsoft Windows XP==<br />
[[Datei: 1 VirtualBox Hauptfenster.png|350px|VirtualBox ohne virtuelle Betriebssysteme]]<br />
<br />
[[Datei: 2 Neue virtuelle Maschine erstellen.png|350px|VirtualBox: Neue virtuelle Maschine erstellen]]<br />
<br />
[[Datei: 3 Virtuelle Maschine fuer Windows erstellen.png|350px|VirtualBox: Betriebssystem auswählen]]<br />
<br />
[[Datei: 4 Groesse des Hauptspeichers festlegen.png|350px|VirtualBox: Größe des zu verwendenden Hauptspeichers angegeben. Max 1/2 des verfügbaren RAM!]]<br />
<br />
[[Datei: 5 Virtuelle Festplatte zuweisen.png|350px|VirtualBox: Virtuelle Festplatte erzeugen]]<br />
<br />
[[Datei: 6 Neue virtuelle Festplatte erstellen.png|350px|]]<br />
<br />
[[Datei: 7 Typ der Festplatte.png|350px|VirtualBox: Typ der Festplatte festlegen]]<br />
<br />
[[Datei: 8 Groesse der neuen Festplatte.png|350px|VirtualBox: Größe der virtuellen Festplatte angeben]]<br />
<br />
[[Datei: 9 Zusammenfassung der Plattenerzeugung.png|350px|VirtualBox: Zusammenfassung der Einstellungen]]<br />
<br />
[[Datei: 10 Angelegte Festpatte uebernehmen.png|350px|VirtualBox: Abgaben prüfen]]<br />
<br />
[[Datei: 11 Zusammenfassung.png|350px|VirtualBox: Zusammenfassung der Einstellungen]]<br />
<br />
[[Datei: 12 OS fertig eingerichtet.png|350px|VirtualBox: Fertig. Bereit zur Installation des Betriebssystems]]<br />
<br />
[[Datei: Bildschirmfoto-Windows XP Laufend - VirtualBox OSE.png|350px|VirtualBox: Installation von Microsoft Windows XP]]<br />
<br />
[[Datei: Bildschirmfoto-Windows XP Laufend - VirtualBox OSE - Windows installiert.png|350px|VirtualBox: Frisch installiertes Microsoft Windows XP]]<br />
<br />
=VBoxGuestAdditions=<br />
<br />
=Tipps und Tricks=<br />
==Desktop-Verknüpfung für ein Betriebssystem erzeugen=<br />
[[Datei:VirtualBox_Desktop-Verknüpfung_erzeugen.png|thumb|350px|VirtualBox: Desktop-Verknüpfung erzeugen]]<br />
Wie wir gesehen haben, kann der Start eines virtuellen Betriebssystems mit etwas Aufwand verbunden sein. Man kann aber auch eine Desktop-Verknüpfung anlegen, so dass das virtuelle Betriebssystem zentraler zu finden und schneller zu starten sein wird.<br />
<br />
Zunächst starten wir den '''VirtualBox Manager'''. Anschließend führen wir einen Rechtsklick auf das gewünschte Betriebssystem aus und wählen im sich öffnenden Kontextmenü den Menüpunkt '''Desktop-Verknüpfung erzeugen''' aus.<br />
<br />
==Virtuelle Festplatte nachträglich vergrößern==<br />
In den meisten Fällen wird die ursprünglich angelegte Größe der virtuellen Festplatte (.vdi) früher oder später nicht mehr ausreichen.<br />
<br />
Dann kann mit dem mitgelieferten Tool VBoxManage die Größe nachträglich gesetzt werden.<br />
<br />
Der Befehl für Windows sieht so aus:<br />
vboxmanage modifyhd <Pfad zur vdi-Datei> -resize <Neue Größe in MB><br />
<br />
Unter Linux ganz ähnlich:<br />
vboxmanage modifyhd <Pfad zur vdi-Datei> --resize <Neue Größe in MB><br />
<br />
<br />
[[Kategorie:Linux]]<br />
[[Kategorie:Ubuntu]]<br />
[[Kategorie:Debian]]<br />
[[Kategorie:Windows]]<br />
[[Kategorie:Tutorials]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=VirtualBox&diff=7581VirtualBox2018-02-25T10:30:15Z<p>L-ectron-x: </p>
<hr />
<div>{{Unvollständig}}<br />
<br />
[[Bild:VirtualBox (Windows).png|thumb|350px|VirtualBox unter Windows]]<br />
<br />
=Installation=<br />
==Unter Windows==<br />
<br />
<br />
==Unter Linux (Debian/Ubuntu)==<br />
Das Programm kann mit folgendem Konsolenbefehl installiert werden:<br/><br />
'''Terminal/Konsole: '''([http://wiki.byte-welt.de/wiki/Software_installieren_(Ubuntu) Paket installieren])<br/><br />
<code=text>sudo apt-get install virtualbox</code=text><br />
Unter Umständen kann es in älteren [[Ubuntu]]-Versionen zu Fehlermeldungen kommen, die auf das fehlende [[Paket]] libxalan110 verweisen.<br />
Dann muss noch zuerst das Paket libxalan110 installiert werden.<br/><br />
'''Terminal/Konsole: '''(Paket installieren)<br/><br />
<code=text>sudo apt-get install libxalan110</code=text><br />
Dabei werden zunächst benötigte Pakete heruntergeladen und gleich darauf installiert.<br/><br />
[http://wiki.byte-welt.de/wiki/VirtualBox_(Ubuntu)#Inbetriebnahme Weiter geht's bei Inbetriebnahme].<br />
<br />
=Manueller Download=<br />
'''Folgende Variante beschreibt die Installation nach manuellem Download der aktuellen Version'''<br />
*Zunächst sollte die aktuellste VirtualBox Version für Linux [http://www.virtualbox.org/wiki/Downloads hier] heruntergeladen werden.<br/><br />
*Das Paket ist im Format .deb verfügbar, das heißt es kann einfach mit Mausdoppelklick installiert werden.<br/><br />
<br />
=Inbetriebnahme=<br />
Um möglichst viele Funktionen von VirtualBox nutzen zu können, sollten zur Inbetriebnahme einige Arbeiten nach der Installation durchgeführt werden.<br />
<br />
==Linux==<br />
'''Anpassungen nach der Installation'''<br />
*Wenn VirtualBox fehlerfrei installiert wurde, müssen anschließend alle Benutzer, die VirtualBox benutzen dürfen zur Gruppe '''vboxusers''' hinzugefügt werden.<br />
'''Terminal/Konsole:''' (Benutzer einer Gruppe hinzufügen)<br/><br />
<code=text>sudo adduser benutzerkonto vboxusers</code=text><br />
ODER auch<br />
<code=text>sudo usermod -aG vboxusers $USER</code=text><br />
<br />
'''Wichtig! Wenn der aktuelle Benutzer bzw. der Benutzer, der mit VirtualBox arbeiten soll nicht der Benutzergruppe '''''vboxusers''''' hinzugefügt wird, können z.B. keine USB-Geräte in den virtuellen Betriebssystemen eingebunden werden.'''<br />
<br />
*Anschließend muss eine Ab- und Wiederanmeldung am System erfolgen.<br />
*VirtualBox ist nun fertig eingerichtet und kann über Anwendungen -> Systemwerkzeuge oder in der Konsole mit dem Befehl '''virtualbox''' gestartet werden.<br />
<br />
=Konfiguration=<br />
<br />
=Installation eines virtuellen Betriebssystems=<br />
==Am Beispiel Microsoft Windows XP==<br />
[[Datei: 1 VirtualBox Hauptfenster.png|350px|VirtualBox ohne virtuelle Betriebssysteme]]<br />
<br />
[[Datei: 2 Neue virtuelle Maschine erstellen.png|350px|VirtualBox: Neue virtuelle Maschine erstellen]]<br />
<br />
[[Datei: 3 Virtuelle Maschine fuer Windows erstellen.png|350px|VirtualBox: Betriebssystem auswählen]]<br />
<br />
[[Datei: 4 Groesse des Hauptspeichers festlegen.png|350px|VirtualBox: Größe des zu verwendenden Hauptspeichers angegeben. Max 1/2 des verfügbaren RAM!]]<br />
<br />
[[Datei: 5 Virtuelle Festplatte zuweisen.png|350px|VirtualBox: Virtuelle Festplatte erzeugen]]<br />
<br />
[[Datei: 6 Neue virtuelle Festplatte erstellen.png|350px|]]<br />
<br />
[[Datei: 7 Typ der Festplatte.png|350px|VirtualBox: Typ der Festplatte festlegen]]<br />
<br />
[[Datei: 8 Groesse der neuen Festplatte.png|350px|VirtualBox: Größe der virtuellen Festplatte angeben]]<br />
<br />
[[Datei: 9 Zusammenfassung der Plattenerzeugung.png|350px|VirtualBox: Zusammenfassung der Einstellungen]]<br />
<br />
[[Datei: 10 Angelegte Festpatte uebernehmen.png|350px|VirtualBox: Abgaben prüfen]]<br />
<br />
[[Datei: 11 Zusammenfassung.png|thumb|350px|VirtualBox: Zusammenfassung der Einstellungen]]<br />
<br />
[[Datei: 12 OS fertig eingerichtet.png|thumb|350px|VirtualBox: Fertig. Bereit zur Installation des Betriebssystems]]<br />
<br />
[[Datei: Bildschirmfoto-Windows XP Laufend - VirtualBox OSE.png|thumb|350px|VirtualBox: Installation von Microsoft Windows XP]]<br />
<br />
[[Datei: Bildschirmfoto-Windows XP Laufend - VirtualBox OSE - Windows installiert.png|thumb|350px|VirtualBox: Frisch installiertes Microsoft Windows XP]]<br />
<br />
=VBoxGuestAdditions=<br />
<br />
=Tipps und Tricks=<br />
==Desktop-Verknüpfung für ein Betriebssystem erzeugen=<br />
[[Datei:VirtualBox_Desktop-Verknüpfung_erzeugen.png|thumb|350px|VirtualBox: Desktop-Verknüpfung erzeugen]]<br />
Wie wir gesehen haben, kann der Start eines virtuellen Betriebssystems mit etwas Aufwand verbunden sein. Man kann aber auch eine Desktop-Verknüpfung anlegen, so dass das virtuelle Betriebssystem zentraler zu finden und schneller zu starten sein wird.<br />
<br />
Zunächst starten wir den '''VirtualBox Manager'''. Anschließend führen wir einen Rechtsklick auf das gewünschte Betriebssystem aus und wählen im sich öffnenden Kontextmenü den Menüpunkt '''Desktop-Verknüpfung erzeugen''' aus.<br />
<br />
==Virtuelle Festplatte nachträglich vergrößern==<br />
In den meisten Fällen wird die ursprünglich angelegte Größe der virtuellen Festplatte (.vdi) früher oder später nicht mehr ausreichen.<br />
<br />
Dann kann mit dem mitgelieferten Tool VBoxManage die Größe nachträglich gesetzt werden.<br />
<br />
Der Befehl für Windows sieht so aus:<br />
vboxmanage modifyhd <Pfad zur vdi-Datei> -resize <Neue Größe in MB><br />
<br />
Unter Linux ganz ähnlich:<br />
vboxmanage modifyhd <Pfad zur vdi-Datei> --resize <Neue Größe in MB><br />
<br />
<br />
[[Kategorie:Linux]]<br />
[[Kategorie:Ubuntu]]<br />
[[Kategorie:Debian]]<br />
[[Kategorie:Windows]]<br />
[[Kategorie:Tutorials]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=VirtualBox&diff=7580VirtualBox2018-02-25T10:24:19Z<p>L-ectron-x: /* Am Beispiel Windows XP */</p>
<hr />
<div>{{Unvollständig}}<br />
<br />
[[Bild:VirtualBox (Windows).png|thumb|350px|VirtualBox unter Windows]]<br />
<br />
=Installation=<br />
==Unter Windows==<br />
<br />
<br />
==Unter Linux (Debian/Ubuntu)==<br />
Das Programm kann mit folgendem Konsolenbefehl installiert werden:<br/><br />
'''Terminal/Konsole: '''([http://wiki.byte-welt.de/wiki/Software_installieren_(Ubuntu) Paket installieren])<br/><br />
<code=text>sudo apt-get install virtualbox</code=text><br />
Unter Umständen kann es in älteren [[Ubuntu]]-Versionen zu Fehlermeldungen kommen, die auf das fehlende [[Paket]] libxalan110 verweisen.<br />
Dann muss noch zuerst das Paket libxalan110 installiert werden.<br/><br />
'''Terminal/Konsole: '''(Paket installieren)<br/><br />
<code=text>sudo apt-get install libxalan110</code=text><br />
Dabei werden zunächst benötigte Pakete heruntergeladen und gleich darauf installiert.<br/><br />
[http://wiki.byte-welt.de/wiki/VirtualBox_(Ubuntu)#Inbetriebnahme Weiter geht's bei Inbetriebnahme].<br />
<br />
=Manueller Download=<br />
'''Folgende Variante beschreibt die Installation nach manuellem Download der aktuellen Version'''<br />
*Zunächst sollte die aktuellste VirtualBox Version für Linux [http://www.virtualbox.org/wiki/Downloads hier] heruntergeladen werden.<br/><br />
*Das Paket ist im Format .deb verfügbar, das heißt es kann einfach mit Mausdoppelklick installiert werden.<br/><br />
<br />
=Inbetriebnahme=<br />
Um möglichst viele Funktionen von VirtualBox nutzen zu können, sollten zur Inbetriebnahme einige Arbeiten nach der Installation durchgeführt werden.<br />
<br />
==Linux==<br />
'''Anpassungen nach der Installation'''<br />
*Wenn VirtualBox fehlerfrei installiert wurde, müssen anschließend alle Benutzer, die VirtualBox benutzen dürfen zur Gruppe '''vboxusers''' hinzugefügt werden.<br />
'''Terminal/Konsole:''' (Benutzer einer Gruppe hinzufügen)<br/><br />
<code=text>sudo adduser benutzerkonto vboxusers</code=text><br />
ODER auch<br />
<code=text>sudo usermod -aG vboxusers $USER</code=text><br />
<br />
'''Wichtig! Wenn der aktuelle Benutzer bzw. der Benutzer, der mit VirtualBox arbeiten soll nicht der Benutzergruppe '''''vboxusers''''' hinzugefügt wird, können z.B. keine USB-Geräte in den virtuellen Betriebssystemen eingebunden werden.'''<br />
<br />
*Anschließend muss eine Ab- und Wiederanmeldung am System erfolgen.<br />
*VirtualBox ist nun fertig eingerichtet und kann über Anwendungen -> Systemwerkzeuge oder in der Konsole mit dem Befehl '''virtualbox''' gestartet werden.<br />
<br />
=Konfiguration=<br />
<br />
=Installation eines virtuellen Betriebssystems=<br />
==Am Beispiel Microsoft Windows XP==<br />
[[Datei: 1 VirtualBox Hauptfenster.png|thumb|350px|VirtualBox ohne virtuelle Betriebssysteme]]<br />
<br />
[[Datei: 2 Neue virtuelle Maschine erstellen.png|thumb|350px|VirtualBox: Neue virtuelle Maschine erstellen]]<br />
<br />
[[Datei: 3 Virtuelle Maschine fuer Windows erstellen.png|thumb|350px|VirtualBox: Betriebssystem auswählen]]<br />
<br />
[[Datei: 4 Groesse des Hauptspeichers festlegen.png|thumb|350px|VirtualBox: Größe des zu verwendenden Hauptspeichers angegeben. Max 1/2 des verfügbaren RAM!]]<br />
<br />
[[Datei: 5 Virtuelle Festplatte zuweisen.png|thumb|350px|VirtualBox: Virtuelle Festplatte erzeugen]]<br />
<br />
[[Datei: 6 Neue virtuelle Festplatte erstellen.png|thumb|350px|]]<br />
<br />
[[Datei: 7 Typ der Festplatte.png|thumb|350px|VirtualBox: Typ der Festplatte festlegen]]<br />
<br />
[[Datei: 8 Groesse der neuen Festplatte.png|thumb|350px|VirtualBox: Größe der virtuellen Festplatte angeben]]<br />
<br />
[[Datei: 9 Zusammenfassung der Plattenerzeugung.png|thumb|350px|VirtualBox: Zusammenfassung der Einstellungen]]<br />
<br />
[[Datei: 10 Angelegte Festpatte uebernehmen.png|thumb|350px|VirtualBox: Abgaben prüfen]]<br />
<br />
[[Datei: 11 Zusammenfassung.png|thumb|350px|VirtualBox: Zusammenfassung der Einstellungen]]<br />
<br />
[[Datei: 12 OS fertig eingerichtet.png|thumb|350px|VirtualBox: Fertig. Bereit zur Installation des Betriebssystems]]<br />
<br />
[[Datei: Bildschirmfoto-Windows XP Laufend - VirtualBox OSE.png|thumb|350px|VirtualBox: Installation von Microsoft Windows XP]]<br />
<br />
[[Datei: Bildschirmfoto-Windows XP Laufend - VirtualBox OSE - Windows installiert.png|thumb|350px|VirtualBox: Frisch installiertes Microsoft Windows XP]]<br />
<br />
=VBoxGuestAdditions=<br />
<br />
=Tipps und Tricks=<br />
==Desktop-Verknüpfung für ein Betriebssystem erzeugen=<br />
[[Datei:VirtualBox_Desktop-Verknüpfung_erzeugen.png|thumb|350px|VirtualBox: Desktop-Verknüpfung erzeugen]]<br />
Wie wir gesehen haben, kann der Start eines virtuellen Betriebssystems mit etwas Aufwand verbunden sein. Man kann aber auch eine Desktop-Verknüpfung anlegen, so dass das virtuelle Betriebssystem zentraler zu finden und schneller zu starten sein wird.<br />
<br />
Zunächst starten wir den '''VirtualBox Manager'''. Anschließend führen wir einen Rechtsklick auf das gewünschte Betriebssystem aus und wählen im sich öffnenden Kontextmenü den Menüpunkt '''Desktop-Verknüpfung erzeugen''' aus.<br />
<br />
==Virtuelle Festplatte nachträglich vergrößern==<br />
In den meisten Fällen wird die ursprünglich angelegte Größe der virtuellen Festplatte (.vdi) früher oder später nicht mehr ausreichen.<br />
<br />
Dann kann mit dem mitgelieferten Tool VBoxManage die Größe nachträglich gesetzt werden.<br />
<br />
Der Befehl für Windows sieht so aus:<br />
vboxmanage modifyhd <Pfad zur vdi-Datei> -resize <Neue Größe in MB><br />
<br />
Unter Linux ganz ähnlich:<br />
vboxmanage modifyhd <Pfad zur vdi-Datei> --resize <Neue Größe in MB><br />
<br />
<br />
[[Kategorie:Linux]]<br />
[[Kategorie:Ubuntu]]<br />
[[Kategorie:Debian]]<br />
[[Kategorie:Windows]]<br />
[[Kategorie:Tutorials]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=Datei:VirtualBox_Desktop-Verkn%C3%BCpfung_erzeugen.png&diff=7579Datei:VirtualBox Desktop-Verknüpfung erzeugen.png2018-02-25T10:13:05Z<p>L-ectron-x: </p>
<hr />
<div></div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=VirtualBox&diff=7578VirtualBox2018-02-25T10:11:23Z<p>L-ectron-x: /* =Desktop-Verknüpfung für ein Betriebssystem erzeugen */</p>
<hr />
<div>{{Unvollständig}}<br />
<br />
[[Bild:VirtualBox (Windows).png|thumb|350px|VirtualBox unter Windows]]<br />
<br />
=Installation=<br />
==Unter Windows==<br />
<br />
<br />
==Unter Linux (Debian/Ubuntu)==<br />
Das Programm kann mit folgendem Konsolenbefehl installiert werden:<br/><br />
'''Terminal/Konsole: '''([http://wiki.byte-welt.de/wiki/Software_installieren_(Ubuntu) Paket installieren])<br/><br />
<code=text>sudo apt-get install virtualbox</code=text><br />
Unter Umständen kann es in älteren [[Ubuntu]]-Versionen zu Fehlermeldungen kommen, die auf das fehlende [[Paket]] libxalan110 verweisen.<br />
Dann muss noch zuerst das Paket libxalan110 installiert werden.<br/><br />
'''Terminal/Konsole: '''(Paket installieren)<br/><br />
<code=text>sudo apt-get install libxalan110</code=text><br />
Dabei werden zunächst benötigte Pakete heruntergeladen und gleich darauf installiert.<br/><br />
[http://wiki.byte-welt.de/wiki/VirtualBox_(Ubuntu)#Inbetriebnahme Weiter geht's bei Inbetriebnahme].<br />
<br />
=Manueller Download=<br />
'''Folgende Variante beschreibt die Installation nach manuellem Download der aktuellen Version'''<br />
*Zunächst sollte die aktuellste VirtualBox Version für Linux [http://www.virtualbox.org/wiki/Downloads hier] heruntergeladen werden.<br/><br />
*Das Paket ist im Format .deb verfügbar, das heißt es kann einfach mit Mausdoppelklick installiert werden.<br/><br />
<br />
=Inbetriebnahme=<br />
Um möglichst viele Funktionen von VirtualBox nutzen zu können, sollten zur Inbetriebnahme einige Arbeiten nach der Installation durchgeführt werden.<br />
<br />
==Linux==<br />
'''Anpassungen nach der Installation'''<br />
*Wenn VirtualBox fehlerfrei installiert wurde, müssen anschließend alle Benutzer, die VirtualBox benutzen dürfen zur Gruppe '''vboxusers''' hinzugefügt werden.<br />
'''Terminal/Konsole:''' (Benutzer einer Gruppe hinzufügen)<br/><br />
<code=text>sudo adduser benutzerkonto vboxusers</code=text><br />
ODER auch<br />
<code=text>sudo usermod -aG vboxusers $USER</code=text><br />
<br />
'''Wichtig! Wenn der aktuelle Benutzer bzw. der Benutzer, der mit VirtualBox arbeiten soll nicht der Benutzergruppe '''''vboxusers''''' hinzugefügt wird, können z.B. keine USB-Geräte in den virtuellen Betriebssystemen eingebunden werden.'''<br />
<br />
*Anschließend muss eine Ab- und Wiederanmeldung am System erfolgen.<br />
*VirtualBox ist nun fertig eingerichtet und kann über Anwendungen -> Systemwerkzeuge oder in der Konsole mit dem Befehl '''virtualbox''' gestartet werden.<br />
<br />
=Konfiguration=<br />
<br />
=Installation eines virtuellen Betriebssystems=<br />
==Am Beispiel Windows XP==<br />
[[Datei: 1 VirtualBox Hauptfenster.png]]<br />
<br />
[[Datei: 2 Neue virtuelle Maschine erstellen.png]]<br />
<br />
[[Datei: 3 Virtuelle Maschine fuer Windows erstellen.png]]<br />
<br />
[[Datei: 4 Groesse des Hauptspeichers festlegen.png]]<br />
<br />
[[Datei: 5 Virtuelle Festplatte zuweisen.png]]<br />
<br />
[[Datei: 6 Neue virtuelle Festplatte erstellen.png]]<br />
<br />
[[Datei: 7 Typ der Festplatte.png]]<br />
<br />
[[Datei: 8 Groesse der neuen Festplatte.png]]<br />
<br />
[[Datei: 9 Zusammenfassung der Plattenerzeugung.png]]<br />
<br />
[[Datei: 10 Angelegte Festpatte uebernehmen.png]]<br />
<br />
[[Datei: 11 Zusammenfassung.png]]<br />
<br />
[[Datei: 12 OS fertig eingerichtet.png]]<br />
<br />
[[Datei: Bildschirmfoto-Windows XP Laufend - VirtualBox OSE.png]]<br />
<br />
[[Datei: Bildschirmfoto-Windows XP Laufend - VirtualBox OSE - Windows installiert.png]]<br />
<br />
=VBoxGuestAdditions=<br />
<br />
=Tipps und Tricks=<br />
==Desktop-Verknüpfung für ein Betriebssystem erzeugen=<br />
[[Datei:VirtualBox_Desktop-Verknüpfung_erzeugen.png|thumb|350px|VirtualBox: Desktop-Verknüpfung erzeugen]]<br />
Wie wir gesehen haben, kann der Start eines virtuellen Betriebssystems mit etwas Aufwand verbunden sein. Man kann aber auch eine Desktop-Verknüpfung anlegen, so dass das virtuelle Betriebssystem zentraler zu finden und schneller zu starten sein wird.<br />
<br />
Zunächst starten wir den '''VirtualBox Manager'''. Anschließend führen wir einen Rechtsklick auf das gewünschte Betriebssystem aus und wählen im sich öffnenden Kontextmenü den Menüpunkt '''Desktop-Verknüpfung erzeugen''' aus.<br />
<br />
==Virtuelle Festplatte nachträglich vergrößern==<br />
In den meisten Fällen wird die ursprünglich angelegte Größe der virtuellen Festplatte (.vdi) früher oder später nicht mehr ausreichen.<br />
<br />
Dann kann mit dem mitgelieferten Tool VBoxManage die Größe nachträglich gesetzt werden.<br />
<br />
Der Befehl für Windows sieht so aus:<br />
vboxmanage modifyhd <Pfad zur vdi-Datei> -resize <Neue Größe in MB><br />
<br />
Unter Linux ganz ähnlich:<br />
vboxmanage modifyhd <Pfad zur vdi-Datei> --resize <Neue Größe in MB><br />
<br />
<br />
[[Kategorie:Linux]]<br />
[[Kategorie:Ubuntu]]<br />
[[Kategorie:Debian]]<br />
[[Kategorie:Windows]]<br />
[[Kategorie:Tutorials]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=VirtualBox&diff=7577VirtualBox2018-02-25T10:10:42Z<p>L-ectron-x: </p>
<hr />
<div>{{Unvollständig}}<br />
<br />
[[Bild:VirtualBox (Windows).png|thumb|350px|VirtualBox unter Windows]]<br />
<br />
=Installation=<br />
==Unter Windows==<br />
<br />
<br />
==Unter Linux (Debian/Ubuntu)==<br />
Das Programm kann mit folgendem Konsolenbefehl installiert werden:<br/><br />
'''Terminal/Konsole: '''([http://wiki.byte-welt.de/wiki/Software_installieren_(Ubuntu) Paket installieren])<br/><br />
<code=text>sudo apt-get install virtualbox</code=text><br />
Unter Umständen kann es in älteren [[Ubuntu]]-Versionen zu Fehlermeldungen kommen, die auf das fehlende [[Paket]] libxalan110 verweisen.<br />
Dann muss noch zuerst das Paket libxalan110 installiert werden.<br/><br />
'''Terminal/Konsole: '''(Paket installieren)<br/><br />
<code=text>sudo apt-get install libxalan110</code=text><br />
Dabei werden zunächst benötigte Pakete heruntergeladen und gleich darauf installiert.<br/><br />
[http://wiki.byte-welt.de/wiki/VirtualBox_(Ubuntu)#Inbetriebnahme Weiter geht's bei Inbetriebnahme].<br />
<br />
=Manueller Download=<br />
'''Folgende Variante beschreibt die Installation nach manuellem Download der aktuellen Version'''<br />
*Zunächst sollte die aktuellste VirtualBox Version für Linux [http://www.virtualbox.org/wiki/Downloads hier] heruntergeladen werden.<br/><br />
*Das Paket ist im Format .deb verfügbar, das heißt es kann einfach mit Mausdoppelklick installiert werden.<br/><br />
<br />
=Inbetriebnahme=<br />
Um möglichst viele Funktionen von VirtualBox nutzen zu können, sollten zur Inbetriebnahme einige Arbeiten nach der Installation durchgeführt werden.<br />
<br />
==Linux==<br />
'''Anpassungen nach der Installation'''<br />
*Wenn VirtualBox fehlerfrei installiert wurde, müssen anschließend alle Benutzer, die VirtualBox benutzen dürfen zur Gruppe '''vboxusers''' hinzugefügt werden.<br />
'''Terminal/Konsole:''' (Benutzer einer Gruppe hinzufügen)<br/><br />
<code=text>sudo adduser benutzerkonto vboxusers</code=text><br />
ODER auch<br />
<code=text>sudo usermod -aG vboxusers $USER</code=text><br />
<br />
'''Wichtig! Wenn der aktuelle Benutzer bzw. der Benutzer, der mit VirtualBox arbeiten soll nicht der Benutzergruppe '''''vboxusers''''' hinzugefügt wird, können z.B. keine USB-Geräte in den virtuellen Betriebssystemen eingebunden werden.'''<br />
<br />
*Anschließend muss eine Ab- und Wiederanmeldung am System erfolgen.<br />
*VirtualBox ist nun fertig eingerichtet und kann über Anwendungen -> Systemwerkzeuge oder in der Konsole mit dem Befehl '''virtualbox''' gestartet werden.<br />
<br />
=Konfiguration=<br />
<br />
=Installation eines virtuellen Betriebssystems=<br />
==Am Beispiel Windows XP==<br />
[[Datei: 1 VirtualBox Hauptfenster.png]]<br />
<br />
[[Datei: 2 Neue virtuelle Maschine erstellen.png]]<br />
<br />
[[Datei: 3 Virtuelle Maschine fuer Windows erstellen.png]]<br />
<br />
[[Datei: 4 Groesse des Hauptspeichers festlegen.png]]<br />
<br />
[[Datei: 5 Virtuelle Festplatte zuweisen.png]]<br />
<br />
[[Datei: 6 Neue virtuelle Festplatte erstellen.png]]<br />
<br />
[[Datei: 7 Typ der Festplatte.png]]<br />
<br />
[[Datei: 8 Groesse der neuen Festplatte.png]]<br />
<br />
[[Datei: 9 Zusammenfassung der Plattenerzeugung.png]]<br />
<br />
[[Datei: 10 Angelegte Festpatte uebernehmen.png]]<br />
<br />
[[Datei: 11 Zusammenfassung.png]]<br />
<br />
[[Datei: 12 OS fertig eingerichtet.png]]<br />
<br />
[[Datei: Bildschirmfoto-Windows XP Laufend - VirtualBox OSE.png]]<br />
<br />
[[Datei: Bildschirmfoto-Windows XP Laufend - VirtualBox OSE - Windows installiert.png]]<br />
<br />
=VBoxGuestAdditions=<br />
<br />
=Tipps und Tricks=<br />
==Desktop-Verknüpfung für ein Betriebssystem erzeugen=<br />
Wie wir gesehen haben, kann der Start eines virtuellen Betriebssystems mit etwas Aufwand verbunden sein. Man kann aber auch eine Desktop-Verknüpfung anlegen, so dass das virtuelle Betriebssystem zentraler zu finden und schneller zu starten sein wird.<br />
<br />
Zunächst starten wir den '''VirtualBox Manager'''. Anschließend führen wir einen Rechtsklick auf das gewünschte Betriebssystem aus und wählen im sich öffnenden Kontextmenü den Menüpunkt '''Desktop-Verknüpfung erzeugen''' aus.<br />
[[Datei:VirtualBox_Desktop-Verknüpfung_erzeugen.png|thumb|350px|VirtualBox: Desktop-Verknüpfung erzeugen]]]<br />
<br />
==Virtuelle Festplatte nachträglich vergrößern==<br />
In den meisten Fällen wird die ursprünglich angelegte Größe der virtuellen Festplatte (.vdi) früher oder später nicht mehr ausreichen.<br />
<br />
Dann kann mit dem mitgelieferten Tool VBoxManage die Größe nachträglich gesetzt werden.<br />
<br />
Der Befehl für Windows sieht so aus:<br />
vboxmanage modifyhd <Pfad zur vdi-Datei> -resize <Neue Größe in MB><br />
<br />
Unter Linux ganz ähnlich:<br />
vboxmanage modifyhd <Pfad zur vdi-Datei> --resize <Neue Größe in MB><br />
<br />
<br />
[[Kategorie:Linux]]<br />
[[Kategorie:Ubuntu]]<br />
[[Kategorie:Debian]]<br />
[[Kategorie:Windows]]<br />
[[Kategorie:Tutorials]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=VirtualBox&diff=7576VirtualBox2018-02-25T10:08:24Z<p>L-ectron-x: /* Tipps und Tricks */</p>
<hr />
<div>{{Unvollständig}}<br />
<br />
[[Bild:VirtualBox (Windows).png|thumb|350px|VirtualBox unter Windows]]<br />
<br />
=Installation=<br />
==Unter Windows==<br />
<br />
<br />
==Unter Linux (Debian/Ubuntu)==<br />
Das Programm kann mit folgendem Konsolenbefehl installiert werden:<br/><br />
'''Terminal/Konsole: '''([http://wiki.byte-welt.de/wiki/Software_installieren_(Ubuntu) Paket installieren])<br/><br />
<code=text>sudo apt-get install virtualbox</code=text><br />
Unter Umständen kann es in älteren [[Ubuntu]]-Versionen zu Fehlermeldungen kommen, die auf das fehlende [[Paket]] libxalan110 verweisen.<br />
Dann muss noch zuerst das Paket libxalan110 installiert werden.<br/><br />
'''Terminal/Konsole: '''(Paket installieren)<br/><br />
<code=text>sudo apt-get install libxalan110</code=text><br />
Dabei werden zunächst benötigte Pakete heruntergeladen und gleich darauf installiert.<br/><br />
[http://wiki.byte-welt.de/wiki/VirtualBox_(Ubuntu)#Inbetriebnahme Weiter geht's bei Inbetriebnahme].<br />
<br />
=Manueller Download=<br />
'''Folgende Variante beschreibt die Installation nach manuellem Download der aktuellen Version'''<br />
*Zunächst sollte die aktuellste VirtualBox Version für Linux [http://www.virtualbox.org/wiki/Downloads hier] heruntergeladen werden.<br/><br />
*Das Paket ist im Format .deb verfügbar, das heißt es kann einfach mit Mausdoppelklick installiert werden.<br/><br />
<br />
=Inbetriebnahme=<br />
Um möglichst viele Funktionen von VirtualBox nutzen zu können, sollten zur Inbetriebnahme einige Arbeiten nach der Installation durchgeführt werden.<br />
<br />
==Linux==<br />
'''Anpassungen nach der Installation'''<br />
*Wenn VirtualBox fehlerfrei installiert wurde, müssen anschließend alle Benutzer, die VirtualBox benutzen dürfen zur Gruppe '''vboxusers''' hinzugefügt werden.<br />
'''Terminal/Konsole:''' (Benutzer einer Gruppe hinzufügen)<br/><br />
<code=text>sudo adduser benutzerkonto vboxusers</code=text><br />
ODER auch<br />
<code=text>sudo usermod -aG vboxusers $USER</code=text><br />
<br />
'''Wichtig! Wenn der aktuelle Benutzer bzw. der Benutzer, der mit VirtualBox arbeiten soll nicht der Benutzergruppe '''''vboxusers''''' hinzugefügt wird, können z.B. keine USB-Geräte in den virtuellen Betriebssystemen eingebunden werden.'''<br />
<br />
*Anschließend muss eine Ab- und Wiederanmeldung am System erfolgen.<br />
*VirtualBox ist nun fertig eingerichtet und kann über Anwendungen -> Systemwerkzeuge oder in der Konsole mit dem Befehl '''virtualbox''' gestartet werden.<br />
<br />
=Konfiguration=<br />
<br />
=Installation eines virtuellen Betriebssystems=<br />
==Am Beispiel Windows XP==<br />
[[Datei: 1 VirtualBox Hauptfenster.png]]<br />
<br />
[[Datei: 2 Neue virtuelle Maschine erstellen.png]]<br />
<br />
[[Datei: 3 Virtuelle Maschine fuer Windows erstellen.png]]<br />
<br />
[[Datei: 4 Groesse des Hauptspeichers festlegen.png]]<br />
<br />
[[Datei: 5 Virtuelle Festplatte zuweisen.png]]<br />
<br />
[[Datei: 6 Neue virtuelle Festplatte erstellen.png]]<br />
<br />
[[Datei: 7 Typ der Festplatte.png]]<br />
<br />
[[Datei: 8 Groesse der neuen Festplatte.png]]<br />
<br />
[[Datei: 9 Zusammenfassung der Plattenerzeugung.png]]<br />
<br />
[[Datei: 10 Angelegte Festpatte uebernehmen.png]]<br />
<br />
[[Datei: 11 Zusammenfassung.png]]<br />
<br />
[[Datei: 12 OS fertig eingerichtet.png]]<br />
<br />
[[Datei: Bildschirmfoto-Windows XP Laufend - VirtualBox OSE.png]]<br />
<br />
[[Datei: Bildschirmfoto-Windows XP Laufend - VirtualBox OSE - Windows installiert.png]]<br />
<br />
=VBoxGuestAdditions=<br />
<br />
=Tipps und Tricks=<br />
==Desktop-Verknüpfung für ein Betriebssystem erzeugen=<br />
Wie wir gesehen haben, kann der Start eines virtuellen Betriebssystems mit etwas Aufwand verbunden sein. Man kann aber auch eine Desktop-Verknüpfung anlegen, so dass das virtuelle Betriebssystem zentraler zu finden und schneller zu starten sein wird.<br />
<br />
Zunächst starten wir den '''VirtualBox Manager'''. Anschließend führen wir einen Rechtsklick auf das gewünschte Betriebssystem aus und wählen im sich öffnenden Kontextmenü den Menüpunkt '''Desktop-Verknüpfung erzeugen''' aus.<br />
[[Datei:VirtualBox_Desktop-Verknüpfung_erzeugen.png]]<br />
<br />
==Virtuelle Festplatte nachträglich vergrößern==<br />
In den meisten Fällen wird die ursprünglich angelegte Größe der virtuellen Festplatte (.vdi) früher oder später nicht mehr ausreichen.<br />
<br />
Dann kann mit dem mitgelieferten Tool VBoxManage die Größe nachträglich gesetzt werden.<br />
<br />
Der Befehl für Windows sieht so aus:<br />
vboxmanage modifyhd <Pfad zur vdi-Datei> -resize <Neue Größe in MB><br />
<br />
Unter Linux ganz ähnlich:<br />
vboxmanage modifyhd <Pfad zur vdi-Datei> --resize <Neue Größe in MB><br />
<br />
<br />
[[Kategorie:Linux]]<br />
[[Kategorie:Ubuntu]]<br />
[[Kategorie:Debian]]<br />
[[Kategorie:Windows]]<br />
[[Kategorie:Tutorials]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=VirtualBox&diff=7575VirtualBox2018-02-25T09:55:45Z<p>L-ectron-x: /* Inbetriebnahme */</p>
<hr />
<div>{{Unvollständig}}<br />
<br />
[[Bild:VirtualBox (Windows).png|thumb|350px|VirtualBox unter Windows]]<br />
<br />
=Installation=<br />
==Unter Windows==<br />
<br />
<br />
==Unter Linux (Debian/Ubuntu)==<br />
Das Programm kann mit folgendem Konsolenbefehl installiert werden:<br/><br />
'''Terminal/Konsole: '''([http://wiki.byte-welt.de/wiki/Software_installieren_(Ubuntu) Paket installieren])<br/><br />
<code=text>sudo apt-get install virtualbox</code=text><br />
Unter Umständen kann es in älteren [[Ubuntu]]-Versionen zu Fehlermeldungen kommen, die auf das fehlende [[Paket]] libxalan110 verweisen.<br />
Dann muss noch zuerst das Paket libxalan110 installiert werden.<br/><br />
'''Terminal/Konsole: '''(Paket installieren)<br/><br />
<code=text>sudo apt-get install libxalan110</code=text><br />
Dabei werden zunächst benötigte Pakete heruntergeladen und gleich darauf installiert.<br/><br />
[http://wiki.byte-welt.de/wiki/VirtualBox_(Ubuntu)#Inbetriebnahme Weiter geht's bei Inbetriebnahme].<br />
<br />
=Manueller Download=<br />
'''Folgende Variante beschreibt die Installation nach manuellem Download der aktuellen Version'''<br />
*Zunächst sollte die aktuellste VirtualBox Version für Linux [http://www.virtualbox.org/wiki/Downloads hier] heruntergeladen werden.<br/><br />
*Das Paket ist im Format .deb verfügbar, das heißt es kann einfach mit Mausdoppelklick installiert werden.<br/><br />
<br />
=Inbetriebnahme=<br />
Um möglichst viele Funktionen von VirtualBox nutzen zu können, sollten zur Inbetriebnahme einige Arbeiten nach der Installation durchgeführt werden.<br />
<br />
==Linux==<br />
'''Anpassungen nach der Installation'''<br />
*Wenn VirtualBox fehlerfrei installiert wurde, müssen anschließend alle Benutzer, die VirtualBox benutzen dürfen zur Gruppe '''vboxusers''' hinzugefügt werden.<br />
'''Terminal/Konsole:''' (Benutzer einer Gruppe hinzufügen)<br/><br />
<code=text>sudo adduser benutzerkonto vboxusers</code=text><br />
ODER auch<br />
<code=text>sudo usermod -aG vboxusers $USER</code=text><br />
<br />
'''Wichtig! Wenn der aktuelle Benutzer bzw. der Benutzer, der mit VirtualBox arbeiten soll nicht der Benutzergruppe '''''vboxusers''''' hinzugefügt wird, können z.B. keine USB-Geräte in den virtuellen Betriebssystemen eingebunden werden.'''<br />
<br />
*Anschließend muss eine Ab- und Wiederanmeldung am System erfolgen.<br />
*VirtualBox ist nun fertig eingerichtet und kann über Anwendungen -> Systemwerkzeuge oder in der Konsole mit dem Befehl '''virtualbox''' gestartet werden.<br />
<br />
=Konfiguration=<br />
<br />
=Installation eines virtuellen Betriebssystems=<br />
==Am Beispiel Windows XP==<br />
[[Datei: 1 VirtualBox Hauptfenster.png]]<br />
<br />
[[Datei: 2 Neue virtuelle Maschine erstellen.png]]<br />
<br />
[[Datei: 3 Virtuelle Maschine fuer Windows erstellen.png]]<br />
<br />
[[Datei: 4 Groesse des Hauptspeichers festlegen.png]]<br />
<br />
[[Datei: 5 Virtuelle Festplatte zuweisen.png]]<br />
<br />
[[Datei: 6 Neue virtuelle Festplatte erstellen.png]]<br />
<br />
[[Datei: 7 Typ der Festplatte.png]]<br />
<br />
[[Datei: 8 Groesse der neuen Festplatte.png]]<br />
<br />
[[Datei: 9 Zusammenfassung der Plattenerzeugung.png]]<br />
<br />
[[Datei: 10 Angelegte Festpatte uebernehmen.png]]<br />
<br />
[[Datei: 11 Zusammenfassung.png]]<br />
<br />
[[Datei: 12 OS fertig eingerichtet.png]]<br />
<br />
[[Datei: Bildschirmfoto-Windows XP Laufend - VirtualBox OSE.png]]<br />
<br />
[[Datei: Bildschirmfoto-Windows XP Laufend - VirtualBox OSE - Windows installiert.png]]<br />
<br />
=VBoxGuestAdditions=<br />
<br />
=Tipps und Tricks=<br />
==Virtuelle Festplatte nachträglich vergrößern==<br />
In den meisten Fällen wird die ursprünglich angelegte Größe der virtuellen Festplatte (.vdi) früher oder später nicht mehr ausreichen.<br />
<br />
Dann kann mit dem mitgelieferten Tool VBoxManage die Größe nachträglich gesetzt werden.<br />
<br />
Der Befehl für Windows sieht so aus:<br />
vboxmanage modifyhd <Pfad zur vdi-Datei> -resize <Neue Größe in MB><br />
<br />
Unter Linux ganz ähnlich:<br />
vboxmanage modifyhd <Pfad zur vdi-Datei> --resize <Neue Größe in MB><br />
<br />
<br />
[[Kategorie:Linux]]<br />
[[Kategorie:Ubuntu]]<br />
[[Kategorie:Debian]]<br />
[[Kategorie:Windows]]<br />
[[Kategorie:Tutorials]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=FTP-Verzeichnis_ins_lokale_Dateisystem_einh%C3%A4ngen&diff=7574FTP-Verzeichnis ins lokale Dateisystem einhängen2018-02-18T18:12:14Z<p>L-ectron-x: Die Seite wurde neu angelegt: „=Quelle= *[https://www.kotori.de/wissen/linux-ftp-verzeichnis-mounten.html FTP-Verzeichnis ins lokale Dateisystem einhängen] Kategorie:Linux Kategorie:…“</p>
<hr />
<div>=Quelle=<br />
*[https://www.kotori.de/wissen/linux-ftp-verzeichnis-mounten.html FTP-Verzeichnis ins lokale Dateisystem einhängen]<br />
<br />
[[Kategorie:Linux]]<br />
[[Kategorie:Debian]]<br />
[[Kategorie:Ubuntu]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=AutofitTableColumns&diff=7573AutofitTableColumns2018-02-17T15:28:16Z<p>L-ectron-x: </p>
<hr />
<div>#WEITERLEITUNG [[Breite von Tabellenspalten automatisch am Zelleninhalt anpassen]]<br />
<br />
[[Kategorie:Java-Codeschnipsel]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=AutofitTableColumns&diff=7572AutofitTableColumns2018-02-17T15:26:36Z<p>L-ectron-x: Weiterleitung nach Breite von Tabellenspalten automatisch am Zelleninhalt anpassen erstellt</p>
<hr />
<div>#WEITERLEITUNG [[Breite von Tabellenspalten automatisch am Zelleninhalt anpassen]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=Grafikdateien_laden_und_anzeigen_(Java)&diff=7571Grafikdateien laden und anzeigen (Java)2018-02-17T14:16:24Z<p>L-ectron-x: </p>
<hr />
<div><br />
<div style="padding:1em;font-size:1.125em;border-style:solid;border-color:#FABD23;border-width:1px;background-color:#F0F0F0;">Häufig möchte man aus verschiedenen Gründen Grafikdateien, wie Icons, Eyecatcher oder Fotos in Java-Programme einbinden.<br><br />
Im Folgenden soll anhand von Code-Beispielen gezeigt werden, wie unter verschiedenen Bedingungen und [[GUI]]-Schnittstellen ([[AWT]]/[[Swing]]) Grafiken eingebunden werden können.<br><br />
'''Dieses Tutorial versucht sämtliche Möglichkeiten und Sachverhalte vom Laden von Grafikdateien in Java näher zu beleuchten und geht dabei auch auf die Unterschiede zwischen AWT, Swing und JavaFX ein.'''</div><br />
<br />
<br />
<br />
=Kleiner Pfad-Exkurs=<br />
Das häufigste Problem, das von Einsteigern beschrieben wird, ist das Laden von Bildern aus verschiedensten Quellen und da besonders, die Einbindung über die URL oder den Pfad zum Bild.<br />
Denn oft möchte man ein Bild laden, welches sich nicht im gleichen Verzeichnis wie die Bytecode-Datei befindet.<br />
Die folgende kurze Einführung zeigt die Verwendung und die Schreibweisen der Angabe des Pfades zur Referenzierung von Grafikdateien.<br />
<br />
<br />
==Was ist ein Pfad und wie ist er aufgebaut?==<br />
Dateien sind innerhalb eines Dateisystems in Verzeichnissen (Ordnern) gespeichert. Man kann Ordner mit Kisten vergleichen, in denen Dinge bestimmter Kategorien gesammelt werden. Bilder würde man sicher auch in einer separaten Kiste sammeln, statt sie mit Versicherungsdokumenten oder Büchern zu mischen.<br><br />
Manchmal hat man in einer Bilderkiste auch weitere Kästchen, in denen Bilder zu einem ganz bestimmten Thema gesammelt sind. <br />
<br />
Ein Pfad beschreibt nun den genauen Speicherplatz einer Datei in einem Dateisystem. Dabei werden sämtliche Kisten und Kästchen aneinander gereiht, bis man das einzelne Bild aus der Kiste oder dem Kästchen entnehmen kann.<br><br />
Anders gesagt: beschreibt der Pfad den Weg, den man beschreiten muss, um zu einem bestimmten Ziel (hier ist es ein ganz bestimmtes Bild) zu gelangen.<br />
<br />
Ein Beispiel:<br />
/Schrank/Bilderkiste/Urlaubsfotos/Strandkorb.jpg<br />
Diese Art des Pfades wird auch absoluter Pfad genannt, der Weg ist hier vom Start bis zum Ziel vollständig aufgeführt.<br />
<br />
==Absolute Pfadangaben==<br />
Unter einem absoluten Pfad versteht man, ausgehend vom Wurzelverzeichnis, den genauen Speicherort einer Datei im Dateisystem.<br />
<br />
===Beispiel Windows===<br />
Der absolute Pfad, um ein Bild auf der System-Festplatte unter Windows zu finden:<br />
<code>c:\users\byte-welt\pictures\bild.png</code><br />
<br />
Wenn man das aber so im Java-Code einer [[Klasse]] schreibt, wird der [[Compiler]] die Backslashes monieren. Der Backslash dient in Java zur Maskierung von Zeichen, die in Java selbst bereits eine Bedeutung haben.<br><br />
Daher kann man den Pfad nun so schreiben:<br><br />
<code>c:\\users\\byte-welt\\pictures\\bild.png</code><br />
<br />
Diese Schreibweise wird aber nur unter Windows-Systemen ausführbar sein, andere Betriebssysteme werden nichts laden können.<br />
<br />
Daher ist der absolute Pfad (abgesehen vom Laufwerksbuchstaben) in Java-Code am besten immer so zu schreiben:<br><br />
<code>c:/users/byte-welt/pictures/bild.png</code><br />
<br />
Der Compiler wird dann nichts mehr bemängeln und die JRE wird das Zeichen zur Pfadtrennung immer für das jeweilige Betriebssystem richtig setzen.<br />
<br />
===Beispiel Linux===<br />
Der absolute Pfad, um ein Bild auf der Festplatte (/home-Partition) unter Linux zu finden:<br />
<code>/home/byte-welt/pictures/bild.png</code><br />
<br />
===Beispiel Internet===<br />
Der absolute Pfad, um ein Bild von einem Webspace aus dem Internet zu laden:<br />
<code><nowiki>http://byte-welt.net/pictures/bild.png</nowiki></code><br />
<br />
==Relative Pfadangaben==<br />
Unter einem relativen Pfad versteht man einen bekannten Teil des (möglicherweise unbekannten) absoluten (gesamten, existierenden) Pfades zu Dateien im Dateisystem.<br><br />
Es geht hier also um den Speicherort einer Datei, ausgehend von dem Punkt im Dateisystem, an dem man sich gerade befindet. Man muss also gar nicht genau wissen, wo sich die gewünschte Datei im Dateisystem befindet. Es genügt, zu wissen, wie man vom aktuellen "Standort" aus dort hin gelangt.<br />
<br />
Der aktuelle Standort wird mit einem Punkt symbolisiert. Zwei aufeinander folgende Punkte symbolisieren ein Verzeichnis über dem aktuellen Verzeichnis. Im Pfad bedeutet das, man geht einen Schritt zurück.<br><br />
Die jeweiligen Verzeichnisse werden mit einem Slash (unter Unix-Systemen) oder einem Backslash (unter Windows) getrennt.<br />
<br />
===Bilder im Verzeichnis der einbettenden Klasse===<br />
<code>bild.png</code> oder <code>./bild.png</code><br />
<br />
===Bilder eine Verzeichnisebene tiefer===<br />
<code>inhalt/bild.png</code><br />
<br />
zwei Ebenen tiefer:<br />
<code>inhalt/bilder/bild.png</code><br />
<br />
===Bilder eine Verzeichnisebene höher===<br />
<code>../bild.png</code><br />
<br />
zwei Ebenen höher:<br />
<code>../../bild.png</code><br />
<br />
zwei Ebenen höher mit anschließendem Wechsel in ein anderes darunter liegendes Verzeichnis:<br />
<code>../../audio/soundcheck.mp3</code><br />
<br />
=Laden von Grafikdateien im AWT=<br />
Im AWT, welches die Standard-Schnittstelle für die Entwicklung grafischer Benutzeroberflächen bis zur Veröffentlichung von Java 1.2 war, wird das Einlesen von Grafikdaten in [[Applet]]s und Applikationen unterschiedlich gehandhabt. Bis auf den gleichen Namen der benutzten [[Methode]] zum Einlesen, müssen hier verschiedene Konzepte angewendet werden. Das führt oft zu Verwirrung und Vorgehensweisen, die unnötig sind.<br />
<br />
==Applets==<br />
<br />
===Laden von Bildern in Applets===<br />
Da Applets auf einem [[Webserver]] gespeichert sind und nach dem Laden in den [[Browser]] externe Resourcen wie Bilder ebenfalls aus dem Internet nachladen, werden die URLs (Quellenanzeiger) der Resourcen meist ausgehend vom URL des Applets angegeben. Das heißt: getCodeBase() liefert den URL des Applets im Internet bzw. Netzwerk. Und davon ausgehend kann nun der exakte [[Pfad]] zu unserem Bild angegeben werden.<br />
<br />
Beispiele:<br />
<code=java><br />
Image image1 = getImage(getCodeBase(),"Bild1.jpg"); //Das Bild liegt hier im gleichen Verzeichnis, wie das Applet.<br />
<br />
Image image2 = getImage(getCodeBase(),"../Bild2.jpg"); //Das Bild liegt hier im Verzeichnis über dem Applet.<br />
<br />
Image image3 = getImage(getCodeBase(),"bilder/Bild3.jpg"); //Das Bild liegt hier vom Applet ausgehend in einem Unterverzeichnis bilder.<br />
<br />
Image image4 = getImage(new URL("http://www.meine-domain.de/bilder/Bild3.jpg")); //Nicht erlaubt! Wirft eine AccessControlException.<br />
</code=java><br />
Beim Programmieren sollte darauf geachtet werden, dass generell Slashes (also '''/''') als Pfadseparatoren verwendet werden. Auch unter Windows! Sonst müsste jeder Pfadseparator escaped werden, was wieder zu einer Plattformabhängigkeit führt.<br />
<br />
===Einfache Applet-Klasse===<br />
Die einfachste Variante, eine Grafik in ein Applet (AWT) einzubinden ist, sie von der URL einzulesen und in der paint()-Methode direkt auf die Appletfläche zu zeichnen.<br />
<br />
<code=java>import java.awt.*;<br />
import java.applet.*;<br />
<br />
public class PictureApplet extends Applet {<br />
private Image image;<br />
<br />
public void init() {<br />
image = getImage(getCodeBase(),"Bild.jpg");<br />
}<br />
<br />
public void paint(Graphics g) {<br />
super.paint(g);<br />
if(image != null) {<br />
g.drawImage(image, 0, 0, this);<br />
}<br />
}<br />
}</code=java><br />
<br />
Diese Variante ist aber wenig effizient und häufig kommt es vor, dass kein Bild ausgegeben wird, obwohl der URL und der Pfad zum Bild stimmen.<br />
Das Einlesen des Bildes dauert hier bei größeren und/oder mehreren Dateien etwas länger, so dass die paint()-Methode schon ausgeführt wird, obwohl das Laden des Bildes noch nicht abgeschlossen ist.<br />
In der Java-Konsole würde in diesem Fall eine NullPointerException ausgegeben werden, wenn '''image''' nicht auf ''null'' geprüft werden würde.<br />
Wegen der Prüfung, stürzt das Programm in dem Fall nicht ab, es zeichnet aber u. U. auch kein Bild.<br />
Um sicherzustellen, dass das Bild fertig geladen ist, bevor die Zeichenroutine angestoßen wird, wird der Einsatz der Klasse [http://wiki.byte-welt.net/wiki/Grafikdateien_laden_und_anzeigen#Einsatz_des_MediaTrackers MediaTracker] empfohlen.<br />
<br />
<br />
==Einsatz des MediaTrackers==<br />
Um sicher zu stellen, dass ein Bild erst dann auf eine AWT-Anwendung gezeichnet wird, wenn es wirklich vollständig geladen wurde, bedient man sich der Klasse [http://docs.oracle.com/javase/7/docs/api/java/awt/MediaTracker.html java.awt.MediaTracker], welche das Laden der Dateien in einem extra [[Thread]] überwacht und die Kontrolle ans Programm zurückgibt, wenn die Bilder geladen wurden.<br />
<br />
Beispiel:<br />
<code=java>import java.awt.*;<br />
import java.applet.*;<br />
<br />
public class PictureApplet extends Applet {<br />
private Image image;<br />
private MediaTracker tracker;<br />
<br />
public void init() {<br />
tracker = new MediaTracker(this);<br />
<br />
image = getImage(getCodeBase(),"Bild.jpg"); //Laden des Bildes anstoßen<br />
<br />
tracker.addImage(image, 0); //Image an den MediaTracker zur Überwachung übergeben<br />
<br />
try {<br />
tracker.waitForAll(); //auf alle zu ladenden Dateien warten<br />
}<br />
catch (InterruptedException e) {<br />
e.printStackTrace(); //Fehlerausgabe auf der Java-Konsole<br />
}<br />
}<br />
<br />
public void paint(Graphics g) {<br />
super.paint(g);<br />
if(image != null) {<br />
g.drawImage(image, 0, 0, this);<br />
}<br />
}<br />
}</code=java><br />
Auch hier, liegt das Bild im gleichen Verzeichnis, wie das Applet.<br><br />
Die Vorgehensweise bei der Benutzung von MediaTracker in Applikationen ist die gleiche, nur dass Bilder dort mit der getImage()-Methode aus [http://docs.oracle.com/javase/7/docs/api/java/awt/Toolkit.html java.awt.Toolkit] geladen werden.<br />
<br />
<br />
==AWT-Applikationen==<br />
<br />
===Laden von Bildern für AWT-Applikationen===<br />
Anwendungen, welche das AWT als GUI-Schnittstelle anwenden, greifen auf die Klasse java.awt.Toolkit zurück, um Bilder zu laden<br />
<code=java><br />
Image image = Toolkit.getDefaultToolkit().getImage("picture.jpg");<br />
</code=java><br />
Genau wie bei Applets muss hier damit gerechnet werden, dass u. U. das Bilder nicht gezeichnet wird, obwohl der Pfad zum Bild stimmt. Stattdessen erhält man eine [[NullPointerException]] (siehe [[Was ist eine Exception?]]).<br />
Auch hier empfiehlt sich zusätzlich der Einsatz von [http://wiki.byte-welt.net/wiki/Grafikdateien_laden_und_anzeigen#Einsatz_des_MediaTrackers MediaTracker], um sicherzustellen, dass das Bild im Speicher ist, bevor die Zeichenroutine angestoßen wird.<br />
<br />
===Ausgabe von Bildern in GUI-Komponenten===<br />
Die meisten GUI-Komponenten des AWT haben von Hause aus keine Möglichkeiten mitbekommen, um Bilder und Grafiken anzuzeigen. Diese Fähigkeiten müssen ihnen nachträglich vom Programmierer verliehen werden.<br />
Dazu ist es erforderlich, vom gewünschten Objekt-Typ zu erben und Methoden zur Ausgabe einzufügen. Im Folgenden werden wir das am Beispiel eines [http://docs.oracle.com/javase/7/docs/api/java/awt/Panel.html java.awt.Panel] demonstrieren.<br />
<code=java><br />
public class ImagePanel extends Panel {<br />
private Image image;<br />
<br />
public ImagePanel(Image image) {<br />
setImage(image);<br />
}<br />
<br />
public void setImage(Image image) {<br />
this.image = image;<br />
repaint();<br />
}<br />
<br />
public Dimension getPreferredSize() {<br />
return new Dimension(image.getWidth(this), image.getHeight(this)));<br />
}<br />
<br />
public void paint(Graphics g) {<br />
super.paint(g);<br />
if(image != null) {<br />
g.drawImage(image, 0, 0, this);<br />
}<br />
}<br />
}<br />
</code=java><br />
Dieses Panel kann in AWT-Anwendungen nun Bilder anzeigen. [http://wiki.byte-welt.net/wiki/LayoutManager_der_Standard-Java-API LayoutManager] berechnen auch den Platz, den das Label im Layout benötigen wird.<br />
<br />
=Laden von Grafikdateien in Swing=<br />
In Swing haben die Java-Erfinder von Sun sehr leistungsfähige Klassen für das Einlesen von Grafikdaten aus unterschiedlichen Quellen entwickelt, die auch die Anwendung in Applets und Applikationen vereinheitlicht.<br />
<br />
<br />
==Varianten zum Einbinden von Grafiken==<br />
Viele Wege führen bekanntlich nach Rom, so auch beim erfolgreichen Laden und Anzeigen von Grafikdateien in Java.<br><br />
<br />
===ImageIO===<br />
{{JAPI|javax.imageio.ImageIO}} ist eine sehr effiziente und einfach zu handhabende Klasse zum Laden von Grafikdateien.<br><br />
Sie stellt u.a. Methoden bereit, um Bilder aus verschiedenen Quellen zu laden. So z.B. aus einer Datei, einem {{JAPI|InputStream}} oder von einer {{JAPI|URL}}.<br />
Ergebnis des Einlesens mit {{JAPI|ImageIO}} ist immer ein Objekt vom Typ {{JAPI|BufferedImage}}, welches die Klasse {{JAPI|java.awt.Image}} erweitert.<br />
<br />
<br />
'''Laden aus einer Datei mit Angabe ihres Namens:'''<br><br />
<code=java>Image image = ImageIO.read(new File("demo.jpg"));</code=java><br />
Diese Variante ist für das Laden von Bildern aus Dateien des lokalen Dateisystems geeignet. Z.B. mit Hilfe von [http://docs.oracle.com/javase/tutorial/uiswing/components/filechooser.html JFileChooser]<br><br />
Sie kommt aber nicht für die Verwendung von Applets in Frage, weil mit File-Zugriffen auf dem Client unerlaubte Operationen versucht werden würden.<br />
Sie ist also nur für den Gebrauch in Applikationen denkbar.<br />
<br />
<br />
'''Laden eines Bildes aus einem InputStream:'''<br><br />
<code=java>Image image = ImageIO.read(getClass().getResource("demo.jpg"));</code=java> <br />
<code>getClass().getResource("...")</code> <span style="color: green; font-weight: bold;"> erzeugt hier einen InputStream zur Datei. Diese Variante kommt bspw. zum Einsatz, wenn sich Bilder innerhalb einer Jar-Datei befinden. Sie funktioniert aber auch, wenn die Klassen und Grafikdateien noch unverpackt im lokalen Dateisystem liegen. Man braucht also nichts mehr verändern, wenn man später aus den fertigen Klassen eine Jar-Datei erzeugt.</span><br />
<br />
<br />
'''Laden eines Bildes in einem Package relativ zu dieser Klasse aus einem InputStream:'''<br><br />
<code=java>Image image = ImageIO.read(getClass().getResource("../images/demo.jpg"));</code=java> <br />
Es wird ein InputStream zur Datei in einer Jar-Datei erzeugt, der sie aus einem Verzeichnis relativ zu dieser Klasse läd.<br />
<br />
<br />
'''Laden eines Bildes in einem Package absolut zu einer Klasse aus einem InputStream:'''<br><br />
<code=java>Image image = ImageIO.read(getClass().getResource("/de/any-domain/project/images/demo.jpg"));</code=java> <br />
Es wird ein InputStream zur Datei erzeugt, der ausgehend vom obersten Package ganz genau den Speicherort in einer Jar-Datei spezifiziert.<br />
<br />
<br />
'''Laden eines Bildes von einer URL:'''<br><br />
<code=java>Image image = ImageIO.read(new URL("http://www.any-domain.de/images/demo.jpg"));</code=java><br />
Diese Variante kommt zum Einsatz, wenn Bilder aus einem Netzwerk geladen werden sollen.<br />
<br />
<br />
Weil dabei auch etwas schief gehen kann, muss der Abschnitt jeweils in einem try-catch - Block eingebaut werden.<br />
<br />
'''ImageIO wird meistens dann benutzt, wenn man Grafikdateien laden und diese später selbst auf GUI-Komponenten zeichnen möchte.'''<br />
<br />
===ImageIcon===<br />
[[Objekt]]e von {{JAPI|ImageIcon}} sind zur direkten Verwendung auf Swing-GUI-Komponenten wie bspw. {{JAPI|JButton}}, {{JAPI|JLabel}}, {{JAPI|JMenuItem}} etc. vorgesehen. Sie sind die Repräsentation von Icons oder Bildern, die auf der lokalen Festplatte, in einem Netzwerk, oder bereits im Speicher als Image-Objekt vorliegen.<br><br />
'''javax.swing.ImageIcon''' ist also eine konkrete Implementierung des '''Icon'''-Interfaces, welches grundlegende Methoden für die Arbeit mit Icons oder Abbildungen definiert.<br><br />
Das Laden der Bilder wird im Hintergrund bereits mit dem {{JAPI|java.awt.Mediatracker}} überwacht, so dass die Bilder auf jeden Fall im Speicher sind, bevor sie gezeichnet werden.<br><br />
Der [[Konstruktor]] von ImageIcon erwartet die Übergabe des Pfades zum Speicherort bzw. den Namen der zu ladenen Datei in Form eines Strings oder in Form eines {{JAPI|Image}} oder einer {{JAPI|URL}}.<br />
Demzufolge können Bilder aus Grafikdateien wie folgt in ImageIcon-Objekten referenziert werden:<br />
<br />
Referenzierung eines Bildes mit Hilfe eines vorher geladenen Image-Objektes:<br />
<code=java><br />
JButton button = null;<br />
ImageIcon icon = null;<br />
<br />
try {<br />
Image image = ImageIO.read("demo.jpg");<br />
icon = new ImageIcon(image);<br />
}<br />
catch(IOException e) {<br />
e.printStackTrace();<br />
}<br />
<br />
button = new JButton("Demo", icon);</code=java><br />
<br />
Das gleiche Ergebnis erhalten wir mit Referenzierung eines Bildes mit Hilfe des Dateinamens:<br />
<code=java><br />
ImageIcon icon = new ImageIcon("demo.jpg");<br />
JButton button = new JButton("Demo", icon);</code=java><br />
Das Bild befindet sich bei diesem Beipsiel in der lokalen Verzeichnisebene, im gleichen Verzeichnis ''dieser'' Klasse.<br />
<br />
Referenzierung eines Bildes in einem Netzwerk mit Hilfe einer URL:<br />
<code=java><br />
ImageIcon icon = new ImageIcon(new URL("http://www.any-domain.de/images/demo.jpg"));<br />
JButton button = new JButton("Demo", icon);</code=java><br />
<br />
Referenzierung eines Bildes, welches in der gleichen Jar-Datei gespeichert wurde.<br />
<code=java><br />
ImageIcon icon = new ImageIcon(getClass().getResource("demo.jpg"));<br />
JButton button = new JButton("Demo", icon);</code=java><br />
<br />
Ein ImageIcon wird immer nach den Vorgaben der einbettenden Komponente (JLabel, JButton etc.) gezeichnet bzw. angeordnet. Man hat hier also weniger Einfluss auf die Darstellung.<br />
<br />
=Laden von Bildern in JavaFX=<br />
Swing verliert nach und nach den Einfluss in der GUI-Programmierung in Java. JavaFX bietet gegenüber Swing weitaus mehr Möglichkeiten bei der Gestaltung von Benutzeroberflächen.<br><br />
Auch der Code zum Einbinden von Bildern ändert sich. Das wollen wir im Folgenden anhand von Beispielen demonstrieren. (Vielen Dank an unseren Benutzer '''ionutbaiu''' für das Kapitel)<br />
<br />
Die Änderungen zum Laden von Bildern in JavaFX gegenüber Swing bestehen in den Folgenden Punkten:<br />
<br />
1. Es wird nun die Klasse {{JAPI|javafx.scene.image.Image}} im Gegensatz zu {{JAPI|java.awt.Image}} verwendet.<br><br />
2. Die Image-Klasse besitzt nun verschiedene Konstruktoren, die im wesentlichen die Aufgaben der Read-Funktionen aus {{JAPI|ImageIO}} ersetzen, um Bilder aus verschiedenen Quellen zu laden.<br />
<br />
In JavaFX gibt es mehrere Möglichkeiten Bilder zu verwenden.<br />
<br />
==Bilder als Hintergrund==<br />
Bilder können als Hintergrund eines Elements verwendet werden.<br />
<br />
Das vorgehen hierbei ist wie folgt.<br />
<br />
'''1. Bild laden'''<br />
<code=java>Image imgBackground = new Image(getClass().getResource("images/background.jpg").toExternalForm());</code=java><br />
<br />
'''2. Bild in ein Hintergrundbild umwandeln'''<br />
<code=java><br />
BackgroundImage backgroundImage = new BackgroundImage(<br />
imgBackground,<br />
BackgroundRepeat.NO_REPEAT,<br />
BackgroundRepeat.NO_REPEAT,<br />
BackgroundPosition.DEFAULT,<br />
BackgroundSize.DEFAULT);<br />
</code=java><br />
<br />
'''3. Hintergrund erstellen'''<br />
<code=java>Background background = new Background(backgroundImage);</code=java><br />
<br />
'''4. Bei der Komponente (hier root) den neuen Hintergrund setzen'''<br />
<code=java>root.setBackground(background);</code=java><br />
<br />
==Bilder direkt verwenden==<br />
Um Bilder direkt zu verwenden gibt es zudem die Klasse {{JAPI|ImageView}}, diese ist weitestgehend das Pendant zur Klasse {{JAPI|ImageIcon}}.<br />
<br />
'''1. Bild laden'''<br />
<code=java> Image imgIcon = new Image(getClass().getResource("icons/icon.png").toExternalForm());</code=java><br />
<br />
'''2. ImageView mit Bild erstellen'''<br />
<code=java> ImageView imgView = new ImageView(imgIcon);</code=java><br />
<br />
oder direkt<br />
<code=java> ImageView imgView = new ImageView(getClass().getResource("icons/icon.png").toExternalForm());</code=java><br />
<br />
'''3. ImageView dem Scene-Graph hinzufügen'''<br />
<code=java>root.getChildren().add(imgView);</code=java><br />
<br />
oder z.B. einem Button das Bild in Form eines Icons hinzufügen.<br />
<code=java> Button button = new Button("Button mit Bild", imgView);</code=java><br />
<br />
==FXML und CSS==<br />
Mit JavaFX gibt es zudem die Möglichkeit [[FXML]] und [[CSS]] einzusetzen.<br />
Hierbei kann die Oberfläche in [[XML]] definiert werden und das Aussehen mit CSS beeinflusst werden, so daß eine saubere Trennung der Zuständigkeiten möglich ist.<br />
<br />
Eine Oberfläche mit einem Button kann mit FXML wie folgt in der Datei ''picture.fxml'' definiert werden<br />
<code=xml><br />
<?xml version="1.0" encoding="UTF-8"?><br />
<br />
<?import java.lang.*?><br />
<?import java.util.*?><br />
<?import javafx.scene.*?><br />
<?import javafx.scene.control.*?><br />
<?import javafx.scene.layout.*?><br />
<br />
<AnchorPane id="AnchorPane" prefHeight="200" prefWidth="320" xmlns:fx="http://javafx.com/fxml/1" xmlns="http://javafx.com/javafx/8" fx:controller="picture.PictureController"><br />
<children><br />
<Button fx:id="button" layoutX="10" layoutY="10" onAction="#handleButtonAction" text="Button with Icon" /> <br />
</children><br />
</AnchorPane><br />
</code=xml><br />
<br />
In dieser Datei ist noch nichts bezüglich der Bilder zu finden. Um nun Bilder den einzelnen Elementen zuzuweisen wird eine datei pictures.css die so aussieht verwendet.<br />
<code=css><br />
#AnchorPane {<br />
-fx-background-image: url(images/background.jpg);<br />
-fx-background-repeat: no-repeat;<br />
-fx-background-position: center center;<br />
}<br />
<br />
#button {<br />
-fx-graphic: url(icons/icon.png);<br />
}<br />
</code=css><br />
<br />
<br />
Um die Verknüpfung zwischen FXML und CSS zu bekommen, haben die Elemente in der FXML Datei jeweils eine ID.<br />
(<code>id="AnchorPane"</code>, sowie <code>fx:id="button"</code>)<br />
<br />
In der CSS Datei werden diese Elemente mit dem Selektor <code>#AnchorPane</code> und <code>#button</code> herausgesucht um dort das Aussehen und die Bilder zu setzen.<br />
<br />
Um FXML- und CSS-Datei in einer Anwendung zu verbinden kann man wie folgt vorgehen:<br />
<br />
'''1. View aus der FXML-Datei laden'''<br />
<code=java>Parent root = FXMLLoader.load(getClass().getResource("picture.fxml"));</code=java><br />
<br />
'''2. Scene erstellen und View via Konstruktor zuweisen.'''<br />
<code=java>Scene scene = new Scene(root);</code=java><br />
<br />
'''3. CSS-Stylesheet laden und der Scene hinzufügen.'''<br />
<code=java>scene.getStylesheets().add(getClass().getResource("picture.css").toExternalForm());</code=java><br />
<br />
'''4. Anzeigen der Scene'''<br />
<code=java><br />
stage.setScene(scene);<br />
stage.show();<br />
</code=java><br />
<br />
=Code-Beispiele=<br />
<br />
==JApplets==<br />
In Swing-Applets kann für das effiziente Einlesen von Grafikdaten die Klasse javax.imageio.ImageIO verwendet werden.<br><br />
Wie einfach ihre Benutzung ist, werden wir im Anschluss demonstrieren.<br />
<br />
===Einfache JApplet-Klassen===<br />
Zeichnen auf einen Container (JPanel), welcher dem JApplet als Hintergrund hinzugefügt wird:<br />
<code=java><br />
import javax.swing.*;<br />
import javax.imageio.*;<br />
import java.awt.*;<br />
import java.net.*;<br />
import java.io.*;<br />
<br />
<br />
public class PictureApplet extends JApplet {<br />
private Image image, background;<br />
<br />
public void init() {<br />
setContentPane(new MyContentPane());<br />
<br />
try {<br />
image = ImageIO.read(new URL(getCodeBase(), "icon.png"));<br />
background = ImageIO.read(new URL(getCodeBase(), "/images/background.jpg"));<br />
}<br />
catch(IllegalArgumentException iae) {<br />
JOptionPane.showMessageDialog(this, "Grafikdatei nicht gefunden!");<br />
}<br />
catch(IOException ioe) {<br />
JOptionPane.showMessageDialog(this, "Fehler beim Einlesen der Grafikdatei!");<br />
}<br />
}<br />
<br />
private class MyContentPane extends JPanel {<br />
<br />
protected void paintComponent(Graphics g) {<br />
super.paintComponent(g);<br />
if(background != null && image != null) { //beide Bilder müssen im Speicher liegen, sonst wird nichts gezeichnet<br />
g.drawImage(background, 0, 0, this);<br />
g.drawImage(image, 10, 10, this);<br />
}<br />
}<br />
}<br />
}</code=java><br />
<br />
Link: [[Einbinden von Applets in HTML-Dateien]]<br />
<br />
===Applets in Jar-Dateien===<br />
Wenn sich das Applet gemeinsam mit der zu ladenden Grafik in einer Jar-Datei zusammengefasst wurden, muss die Grafik über den ClassLoader ins Applet geladen werden.<br />
<br />
Zeichnen auf einen Container (JPanel), welcher dem JApplet als Hintergrund hinzugefügt wird:<br />
<code=java><br />
import javax.swing.*;<br />
import javax.imageio.*;<br />
import java.awt.*;<br />
import java.net.*;<br />
import java.io.*;<br />
<br />
<br />
public class PictureApplet extends JApplet {<br />
private Image image, background;<br />
<br />
public void init() {<br />
setContentPane(new MyContentPane());<br />
<br />
try {<br />
image = ImageIO.read(getClass().getResource("icon.png"));<br />
background = ImageIO.read(getClass().getResource("images/background.jpg"));<br />
}<br />
catch(IllegalArgumentException iae) {<br />
JOptionPane.showMessageDialog(this, "Grafikdatei nicht gefunden!");<br />
}<br />
catch(IOException ioe) {<br />
JOptionPane.showMessageDialog(this, "Fehler beim Einlesen der Grafikdatei!");<br />
}<br />
}<br />
<br />
private class MyContentPane extends JPanel {<br />
<br />
protected void paintComponent(Graphics g) {<br />
super.paintComponent(g);<br />
if(background != null && image != null) { //beide Bilder müssen im Speicher liegen, sonst wird nichts gezeichnet<br />
g.drawImage(background, 0, 0, this);<br />
g.drawImage(image, 10, 10, this);<br />
}<br />
}<br />
}<br />
}</code=java><br />
<br />
Das Applet-Tag in der HTML-Datei muss jetzt angepasst werden, damit der Browser weiß, wo sich das Applet befindet.<br><br />
Link: [http://wiki.byte-welt.net/wiki/Einbinden_von_Applets_in_HTML-Dateien Applet-Tag für Jar-Dateien]<br />
<br />
<br />
==Swing-Applikationen==<br />
Auch Swing-Applikationen werden im Allgemeinen in Jar-Archiven zusammengefasst. Diese lassen sich auf jedem System per Doppelklick starten, oder per Webstart über das Internet laden.<br><br />
Hier also nun die Variante für eine Applikation. Auffällig ist, dass sich der Code des Panels gegenüber dem Applet nur leicht, der Code zum Laden der Bilder aber gar nicht verändert hat.<br />
<code=java><br />
import javax.swing.*;<br />
import javax.imageio.*;<br />
import java.awt.*;<br />
import java.net.*;<br />
import java.io.*;<br />
<br />
public class PicturePanel extends JPanel { <br />
private Image image, background;<br />
<br />
public PicturePanel() {<br />
super(new GridBagLayout());<br />
<br />
try {<br />
image = ImageIO.read(getClass().getResource("icons/icon.png"));<br />
background = ImageIO.read(getClass().getResource("images/background.jpg"));<br />
}<br />
catch(IllegalArgumentException iae) {<br />
JOptionPane.showMessageDialog(this, "Grafikdatei nicht gefunden!\n"+iae.getMessage());<br />
}<br />
catch(IOException ioe) {<br />
JOptionPane.showMessageDialog(this, "Fehler beim Einlesen einer Grafikdatei!\n"+ioe.getMessage());<br />
}<br />
<br />
JButton pictureButton = new JButton("Button mit Icon", new ImageIcon(image));<br />
add(pictureButton);<br />
}<br />
<br />
@Override<br />
protected void paintComponent(Graphics g) {<br />
super.paintComponent(g);<br />
if(background != null) { //Bild muss im Speicher liegen, sonst wird nichts gezeichnet<br />
g.drawImage(background, 0, 0, this);<br />
}<br />
}<br />
}<br />
</code=java><br />
<br />
Das Ganze kann nun in einem Fenster angezeigt werden:<br />
<code=java><br />
import javax.swing.*;<br />
<br />
public class PictureFrame {<br />
public static void main(String[] args) {<br />
SwingUtilities.invokeLater(new Runnable() {<br />
public void run() {<br />
JFrame f = new JFrame("Bildbetrachter");<br />
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);<br />
f.add(new PicturePanel());<br />
f.pack();<br />
f.setLocationRelativeTo(null);<br />
f.setVisible(true);<br />
}<br />
});<br />
}<br />
}<br />
</code=java><br />
<br />
==JavaFX-Applikationen ==<br />
Wenn man sich nun den Code einer entsprechenden JavaFX-Anwendung ansieht, könnte man meinen, dass es scheinbar Parallelen zu AWT und Swing gibt. Java-FX-Klassen haben nun kein vorangestelltes "J" mehr und die Initialisierung eines {{JAPI|javafx.scene.control.Button}} sieht aus, wie bei einem Swing-{{JAPI|JButton}}. Allerdings gibt es auch Neues, wie nun gezeigt wird:<br />
<code=java><br />
import java.io.PrintWriter;<br />
import java.io.StringWriter;<br />
import javafx.application.Application;<br />
import javafx.scene.Scene;<br />
import javafx.scene.control.Alert;<br />
import javafx.scene.control.Button;<br />
import javafx.scene.image.Image;<br />
import javafx.scene.image.ImageView;<br />
import javafx.scene.layout.Background;<br />
import javafx.scene.layout.BackgroundImage;<br />
import javafx.scene.layout.BackgroundPosition;<br />
import javafx.scene.layout.BackgroundRepeat;<br />
import javafx.scene.layout.BackgroundSize;<br />
import javafx.scene.layout.StackPane;<br />
import javafx.stage.Stage;<br />
<br />
public class Picture extends Application {<br />
<br />
@Override<br />
public void start(Stage primaryStage) {<br />
<br />
try {<br />
Image imgBackground = new Image(getClass().getResource("images/background.jpg").toExternalForm());<br />
BackgroundImage backgroundImage = new BackgroundImage(<br />
imgBackground,<br />
BackgroundRepeat.NO_REPEAT,<br />
BackgroundRepeat.NO_REPEAT,<br />
BackgroundPosition.DEFAULT,<br />
BackgroundSize.DEFAULT);<br />
Background background = new Background(backgroundImage);<br />
<br />
Image imgIcon = new Image(getClass().getResource("icons/icon.png").toExternalForm());<br />
ImageView imgView = new ImageView(imgIcon);<br />
<br />
Button btn = new Button("Button mit Icon", imgView);<br />
btn.setText("Button mit Icon");<br />
<br />
StackPane root = new StackPane();<br />
root.getChildren().add(btn);<br />
root.setBackground(background);<br />
<br />
Scene scene = new Scene(root, 300, 250);<br />
<br />
primaryStage.setTitle("Bildbetrachter FX");<br />
primaryStage.setScene(scene);<br />
primaryStage.show();<br />
<br />
} catch (Exception e) {<br />
Alert alert = new Alert(Alert.AlertType.ERROR);<br />
alert.setTitle("Fehler");<br />
<br />
StringWriter sw = new StringWriter();<br />
PrintWriter pw = new PrintWriter(sw);<br />
e.printStackTrace(pw);<br />
<br />
alert.setContentText(sw.toString());<br />
<br />
alert.showAndWait();<br />
}<br />
}<br />
<br />
public static void main(String[] args) {<br />
launch(args);<br />
}<br />
<br />
}</code=java><br />
<br />
<br />
=Grafiken aus externen Jar-Dateien laden=<br />
Im Internet sind reichlich freie Quellen zu finden, die spezielle Grafiken (Icons) für die visuelle Kennzeichnung und Verschönerung von GUI-Elementen eingesetzt werden können.<br><br />
Diese Quellen liegen meist in gepackter Form als Zip-Archiv vor. Um sie für ein Java-Programm nutzbar zu machen, kann man eine solche Zip-Datei einfach in eine Jar-Datei umbenennen (Datei-Suffix ändern) oder auch, unter Beachtung der Lizenz, einzelne Dateien extrahieren und in eine neue Jar-Datei packen.<br />
Den Weg, Grafikdateien aus der Jar-Datei zu laden, die auch unser Programm enthält, haben wir bereits oben gesehen.<br />
Wir werden uns nun aber mal ansehen, wie Grafikdateien aus externen Bibliotheken bzw. Archiven geladen werden können.<br />
<br />
<br />
==Bibliotheken im Classpath==<br />
(Artikel noch einzufügen)<br />
<br />
<br />
==Bibliotheken außerhalb des Classpaths==<br />
Um Grafikdateien aus einer externen Jar-Datei zu laden, die sich nicht im Sichtbarkeitsbereich des ClassLoaders befindet, kann man den absoluten Pfad zur Jar-Datei entsprechend nach folgendem Schema zusammenbauen:<br />
<br />
jar:protocol//:path/to/jarfile/jarfile.jar!/my/package<br />
<br />
'''protocol''' bezeichnet hier z.B. ''http'' oder ''file''.<br />
Direkt nach der Jar-Datei folgt ein Ausrufezeichen. Was danach folgt ist der Pfad innerhalb der Jar-Datei, also die einzelnen Packages.<br />
<br />
<code=java>URL jarPath = new URL("jar:file://pfad/zur/jardatei/MeinProgramm.jar!/bilder/bild.jpg");</code=java><br />
''/bilder/bild.jpg'' bezeichnet hierbei den Pfad innerhalb der externen Jar-Datei zur Grafikdatei.<br />
<br />
=Fragen stellen=<br />
Wir haben hier bereits viele Dinge beim Umgang mit Grafiken in Java-Programmen besprochen.<br />
Du hast immer noch Fragen? Dann hier im passenden Themenbereich im Byte-Welt-Forum: [https://forum.byte-welt.net/c/java-forum/awt-swing-javafx-swt AWT, Swing, JavaFX & SWT]<br />
[[Kategorie:Java]]<br />
[[Kategorie:Tutorials (Java)]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=Programmierparadigma&diff=7570Programmierparadigma2018-02-17T13:19:18Z<p>L-ectron-x: L-ectron-x verschob die Seite Programmierparadigmen nach Programmierparadigma, ohne dabei eine Weiterleitung anzulegen</p>
<hr />
<div>=Imperativ=<br />
Das Programm besteht aus einer Folge von Anweisungen, die streng sequentiell abgearbeitet werden. Das Konzept des imperativen Programmierparadigmas beruht auf Funktionen und Prozeduren zur Abbildung der Funktionalität und Wiederverwendung von Quellcode.<br />
<br />
=Objektbasiert=<br />
Diese Programmiersprachen kennen [[Objekt|Objekte]] zur [[Kapselung]] von Daten und Funktionalität. Weitergehende Konzepte, wie beispielsweise [[Vererbung]] oder die Darstellung von Beziehungen zwischen Objekten, werden jedoch nicht angeboten. Objektbasierte <br />
Sprachen können damit als Vorstufe der [[Objektorientierte Programmierung (ooP)|objektorientierten Programmierung]] aufgefasst werden.<br />
<br />
=Objektorientiert=<br />
Programmiersprachen dieser Gattung erweitern das objektbasierte Programmierparadigma um die typischen Konzepte der Objektorientierung, wie Vererbung und [[Polymorphie]].<br />
<br />
=Funktional=<br />
Ein funktionales Programm besteht nur aus einer Reihe von Funktionsaufrufen. Eigenständige Wertzuweisungen existieren nicht. Alle Elemente können als [[Funktion|Funktionen]] aufgefasst werden. Einsatzgebiete sind Anwendungen der künstlichen Intelligenz, Compilerbau und Computeralgebra-Systeme.<br />
<br />
=Logisch=<br />
Im Mittelpunkt steht der Aufbau einer Datenbasis, die aus Fakten und Regeln besteht. Fakten sind dabei wahre Aussagen im Sinne der Mathematik. Im Fokus steht die Problemformulierung, nicht der Lösungsalgorithmus.<br />
<br />
=Deklarativ=<br />
Überbegriff für das funktionale und das logische Paradigma.<br />
<br />
=Literaturverzeichnis=<br />
*https://jaxenter.de/java-kurs-teil-3-49623<br />
<br />
[[Kategorie:Programmierung]]<br />
[[Kategorie:Listen]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=Programmierparadigma&diff=7569Programmierparadigma2018-02-17T12:58:09Z<p>L-ectron-x: </p>
<hr />
<div>=Imperativ=<br />
Das Programm besteht aus einer Folge von Anweisungen, die streng sequentiell abgearbeitet werden. Das Konzept des imperativen Programmierparadigmas beruht auf Funktionen und Prozeduren zur Abbildung der Funktionalität und Wiederverwendung von Quellcode.<br />
<br />
=Objektbasiert=<br />
Diese Programmiersprachen kennen [[Objekt|Objekte]] zur [[Kapselung]] von Daten und Funktionalität. Weitergehende Konzepte, wie beispielsweise [[Vererbung]] oder die Darstellung von Beziehungen zwischen Objekten, werden jedoch nicht angeboten. Objektbasierte <br />
Sprachen können damit als Vorstufe der [[Objektorientierte Programmierung (ooP)|objektorientierten Programmierung]] aufgefasst werden.<br />
<br />
=Objektorientiert=<br />
Programmiersprachen dieser Gattung erweitern das objektbasierte Programmierparadigma um die typischen Konzepte der Objektorientierung, wie Vererbung und [[Polymorphie]].<br />
<br />
=Funktional=<br />
Ein funktionales Programm besteht nur aus einer Reihe von Funktionsaufrufen. Eigenständige Wertzuweisungen existieren nicht. Alle Elemente können als [[Funktion|Funktionen]] aufgefasst werden. Einsatzgebiete sind Anwendungen der künstlichen Intelligenz, Compilerbau und Computeralgebra-Systeme.<br />
<br />
=Logisch=<br />
Im Mittelpunkt steht der Aufbau einer Datenbasis, die aus Fakten und Regeln besteht. Fakten sind dabei wahre Aussagen im Sinne der Mathematik. Im Fokus steht die Problemformulierung, nicht der Lösungsalgorithmus.<br />
<br />
=Deklarativ=<br />
Überbegriff für das funktionale und das logische Paradigma.<br />
<br />
=Literaturverzeichnis=<br />
*https://jaxenter.de/java-kurs-teil-3-49623<br />
<br />
[[Kategorie:Programmierung]]<br />
[[Kategorie:Listen]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=Programmierparadigma&diff=7568Programmierparadigma2018-02-17T12:56:01Z<p>L-ectron-x: </p>
<hr />
<div>=Imperativ=<br />
Das Programm besteht aus einer Folge von Anweisungen, die streng sequentiell abgearbeitet werden. Das Konzept des imperativen Programmierparadigmas beruht auf Funktionen und Prozeduren zur Abbildung der Funktionalität und Wiederverwendung von Quellcode.<br />
<br />
=Objektbasiert=<br />
Diese Programmiersprachen kennen [[Objekt|Objekte]] zur [[Kapselung]] von Daten und Funktionalität. Weitergehende Konzepte, wie beispielsweise [[Vererbung]] oder die Darstellung von Beziehungen zwischen Objekten, werden jedoch nicht angeboten. Objektbasierte <br />
Sprachen können damit als Vorstufe der [[Objektorientierte Programmierung (ooP)|objektorientierten Programmierung]] aufgefasst werden.<br />
<br />
=Objektorientiert=<br />
Programmiersprachen dieser Gattung erweitern das objektbasierte Programmierparadigma um die typischen Konzepte der Objektorientierung, wie Vererbung und [[Polymorphie]].<br />
<br />
=Funktional=<br />
Ein funktionales Programm besteht nur aus einer Reihe von Funktionsaufrufen. Eigenständige Wertzuweisungen existieren nicht. Alle Elemente können als [[Funktion|Funktionen]] aufgefasst werden. Einsatzgebiete sind Anwendungen der künstlichen Intelligenz, Compilerbau und Computeralgebra-Systeme.<br />
<br />
=Logisch=<br />
Im Mittelpunkt steht der Aufbau einer Datenbasis, die aus Fakten und Regeln besteht. Fakten sind dabei wahre Aussagen im Sinne der Mathematik. Im Fokus steht die Problemformulierung, nicht der Lösungsalgorithmus.<br />
<br />
=Deklarativ=<br />
Überbegriff für das funktionale und das logische Paradigma.<br />
<br />
==Literaturverzeichnis==<br />
*https://jaxenter.de/java-kurs-teil-3-49623<br />
<br />
[[Kategorie:Programmierung]]<br />
[[Kategorie:Listen]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=Programmierparadigma&diff=7567Programmierparadigma2018-02-17T12:53:57Z<p>L-ectron-x: </p>
<hr />
<div>=Imperativ=<br />
Das Programm besteht aus einer Folge von Anweisungen, die streng sequentiell abgearbeitet werden. Das Konzept des imperativen Programmierparadigmas beruht auf Funktionen und Prozeduren zur Abbildung der Funktionalität und Wiederverwendung von Quellcode.<br />
<br />
=Objektbasiert=<br />
Diese Programmiersprachen kennen [[Objekt|Objekte]] zur [[Kapselung]] von Daten und Funktionalität. Weitergehende Konzepte, wie beispielsweise [[Vererbung]] oder die Darstellung von Beziehungen zwischen Objekten, werden jedoch nicht angeboten. Objektbasierte <br />
Sprachen können damit als Vorstufe der [[OOP|objektorientierten Programmierung]] aufgefasst werden.<br />
<br />
=Objektorientiert=<br />
Programmiersprachen dieser Gattung erweitern das objektbasierte Programmierparadigma um die typischen Konzepte der Objektorientierung, wie Vererbung und [[Polymorphie]].<br />
<br />
=Funktional=<br />
Ein funktionales Programm besteht nur aus einer Reihe von Funktionsaufrufen. Eigenständige Wertzuweisungen existieren nicht. Alle Elemente können als [[Funktion|Funktionen]] aufgefasst werden. Einsatzgebiete sind Anwendungen der künstlichen Intelligenz, Compilerbau und Computeralgebra-Systeme.<br />
<br />
=Logisch=<br />
Im Mittelpunkt steht der Aufbau einer Datenbasis, die aus Fakten und Regeln besteht. Fakten sind dabei wahre Aussagen im Sinne der Mathematik. Im Fokus steht die Problemformulierung, nicht der Lösungsalgorithmus.<br />
<br />
=Deklarativ=<br />
Überbegriff für das funktionale und das logische Paradigma.<br />
<br />
==Literaturverzeichnis==<br />
*https://jaxenter.de/java-kurs-teil-3-49623<br />
<br />
[[Kategorie:Programmierung]]<br />
[[Kategorie:Listen]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=Programmierparadigma&diff=7566Programmierparadigma2018-02-17T12:53:37Z<p>L-ectron-x: </p>
<hr />
<div>=Imperativ=<br />
Das Programm besteht aus einer Folge von Anweisungen, die streng sequentiell abgearbeitet werden. Das Konzept des imperativen Programmierparadigmas beruht auf Funktionen und Prozeduren zur Abbildung der Funktionalität und Wiederverwendung von Quellcode.<br />
<br />
=Objektbasiert=<br />
Diese Programmiersprachen kennen [[Objekt|Objekte]] zur [[Kapselung]] von Daten und Funktionalität. Weitergehende Konzepte, wie beispielsweise [[Vererbung] oder die Darstellung von Beziehungen zwischen Objekten, werden jedoch nicht angeboten. Objektbasierte <br />
Sprachen können damit als Vorstufe der [[OOP|objektorientierten Programmierung]] aufgefasst werden.<br />
<br />
=Objektorientiert=<br />
Programmiersprachen dieser Gattung erweitern das objektbasierte Programmierparadigma um die typischen Konzepte der Objektorientierung, wie Vererbung und [[Polymorphie]].<br />
<br />
=Funktional=<br />
Ein funktionales Programm besteht nur aus einer Reihe von Funktionsaufrufen. Eigenständige Wertzuweisungen existieren nicht. Alle Elemente können als [[Funktion|Funktionen]] aufgefasst werden. Einsatzgebiete sind Anwendungen der künstlichen Intelligenz, Compilerbau und Computeralgebra-Systeme.<br />
<br />
=Logisch=<br />
Im Mittelpunkt steht der Aufbau einer Datenbasis, die aus Fakten und Regeln besteht. Fakten sind dabei wahre Aussagen im Sinne der Mathematik. Im Fokus steht die Problemformulierung, nicht der Lösungsalgorithmus.<br />
<br />
=Deklarativ=<br />
Überbegriff für das funktionale und das logische Paradigma.<br />
<br />
==Literaturverzeichnis==<br />
*https://jaxenter.de/java-kurs-teil-3-49623<br />
<br />
[[Kategorie:Programmierung]]<br />
[[Kategorie:Listen]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=Programmierparadigma&diff=7565Programmierparadigma2018-02-17T12:53:17Z<p>L-ectron-x: </p>
<hr />
<div>=Imperativ=<br />
Das Programm besteht aus einer Folge von Anweisungen, die streng sequentiell abgearbeitet werden. Das Konzept des imperativen Programmierparadigmas beruht auf Funktionen und Prozeduren zur Abbildung der Funktionalität und Wiederverwendung von Quellcode.<br />
<br />
=Objektbasiert=<br />
Diese Programmiersprachen kennen [[Objekt|Objekte] zur [[Kapselung]] von Daten und Funktionalität. Weitergehende Konzepte, wie beispielsweise [[Vererbung] oder die Darstellung von Beziehungen zwischen Objekten, werden jedoch nicht angeboten. Objektbasierte <br />
Sprachen können damit als Vorstufe der [[OOP|objektorientierten Programmierung]] aufgefasst werden.<br />
<br />
=Objektorientiert=<br />
Programmiersprachen dieser Gattung erweitern das objektbasierte Programmierparadigma um die typischen Konzepte der Objektorientierung, wie Vererbung und [[Polymorphie]].<br />
<br />
=Funktional=<br />
Ein funktionales Programm besteht nur aus einer Reihe von Funktionsaufrufen. Eigenständige Wertzuweisungen existieren nicht. Alle Elemente können als [[Funktion|Funktionen]] aufgefasst werden. Einsatzgebiete sind Anwendungen der künstlichen Intelligenz, Compilerbau und Computeralgebra-Systeme.<br />
<br />
=Logisch=<br />
Im Mittelpunkt steht der Aufbau einer Datenbasis, die aus Fakten und Regeln besteht. Fakten sind dabei wahre Aussagen im Sinne der Mathematik. Im Fokus steht die Problemformulierung, nicht der Lösungsalgorithmus.<br />
<br />
=Deklarativ=<br />
Überbegriff für das funktionale und das logische Paradigma.<br />
<br />
==Literaturverzeichnis==<br />
*https://jaxenter.de/java-kurs-teil-3-49623<br />
<br />
[[Kategorie:Programmierung]]<br />
[[Kategorie:Listen]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=Programmierparadigma&diff=7564Programmierparadigma2018-02-17T12:51:06Z<p>L-ectron-x: </p>
<hr />
<div>=Imperativ=<br />
Das Programm besteht aus einer Folge von Anweisungen, die streng sequentiell abgearbeitet werden. Das Konzept des imperativen Programmierparadigmas beruht auf Funktionen und Prozeduren zur Abbildung der Funktionalität und Wiederverwendung von Quellcode.<br />
<br />
=Objektbasiert=<br />
Diese Programmiersprachen kennen Objekte zur Kapselung von Daten und Funktionalität. Weitergehende Konzepte, wie beispielsweise Vererbung oder die Darstellung von Beziehungen zwischen Objekten, werden jedoch nicht angeboten. Objektbasierte <br />
Sprachen können damit als Vorstufe der objektorientierten Programmierung aufgefasst werden.<br />
<br />
=Objektorientiert=<br />
Programmiersprachen dieser Gattung erweitern das objektbasierte Programmierparadigma um die typischen Konzepte der Objektorientierung, wie Vererbung und Polymorphie.<br />
<br />
=Funktional=<br />
Ein funktionales Programm besteht nur aus einer Reihe von Funktionsaufrufen. Eigenständige Wertzuweisungen existieren nicht. Alle Elemente können als Funktionen aufgefasst werden. Einsatzgebiete sind Anwendungen der künstlichen Intelligenz, Compilerbau und Computeralgebra-Systeme.<br />
<br />
=Logisch=<br />
Im Mittelpunkt steht der Aufbau einer Datenbasis, die aus Fakten und Regeln besteht. Fakten sind dabei wahre Aussagen im Sinne der Mathematik. Im Fokus steht die Problemformulierung, nicht der Lösungsalgorithmus.<br />
<br />
=Deklarativ=<br />
Überbegriff für das funktionale und das logische Paradigma.<br />
<br />
==Literaturverzeichnis==<br />
*https://jaxenter.de/java-kurs-teil-3-49623<br />
<br />
[[Kategorie:Programmierung]]<br />
[[Kategorie:Listen]]</div>L-ectron-xhttps://wiki.byte-welt.net/index.php?title=Programmierparadigma&diff=7563Programmierparadigma2018-02-17T12:47:16Z<p>L-ectron-x: Die Seite wurde neu angelegt: „Kategorie:Programmierung =Imperativ= Das Programm besteht aus einer Folge von Anweisungen, die streng sequentiell abgearbeitet werden. Das Konzept des imp…“</p>
<hr />
<div>[[Kategorie:Programmierung]]<br />
<br />
=Imperativ=<br />
Das Programm besteht aus einer Folge von Anweisungen, die streng sequentiell abgearbeitet werden. Das Konzept des imperativen Programmierparadigmas beruht auf Funktionen und Prozeduren zur Abbildung der Funktionalität und Wiederverwendung von Quellcode.<br />
<br />
=Objektbasiert=<br />
Diese Programmiersprachen kennen Objekte zur Kapselung von Daten und Funktionalität. Weitergehende Konzepte, wie beispielsweise Vererbung oder die Darstellung von Beziehungen zwischen Objekten, werden jedoch nicht angeboten. Objektbasierte <br />
Sprachen können damit als Vorstufe der objektorientierten Programmierung aufgefasst werden.<br />
<br />
=Objektorientiert=<br />
Programmiersprachen dieser Gattung erweitern das objektbasierte Programmierparadigma um die typischen Konzepte der Objektorientierung, wie Vererbung und Polymorphie.<br />
<br />
=Funktional=<br />
Ein funktionales Programm besteht nur aus einer Reihe von Funktionsaufrufen. Eigenständige Wertzuweisungen existieren nicht. Alle Elemente können als Funktionen aufgefasst werden. Einsatzgebiete sind Anwendungen der künstlichen Intelligenz, Compilerbau und Computeralgebra-Systeme.<br />
<br />
=Logisch=<br />
Im Mittelpunkt steht der Aufbau einer Datenbasis, die aus Fakten und Regeln besteht. Fakten sind dabei wahre Aussagen im Sinne der Mathematik. Im Fokus steht die Problemformulierung, nicht der Lösungsalgorithmus.<br />
<br />
=Deklarativ=<br />
Überbegriff für das funktionale und das logische Paradigma.<br />
<br />
==Quelle==<br />
*https://jaxenter.de/java-kurs-teil-3-49623</div>L-ectron-x