java_tutorial_openjdk_13_installieren

Java 13 installieren – Installation des OpenJDK Version 13 auf einem Windows 10 PC

In dieser Lektion werden wir ausführlich beschreiben, wie das freie und quelloffene Java Development Kit (OpenJDK 13) auf einem Windows 10 PC installiert wird.

Als ersten Schritt werden wir die aktuelle OpenJDK 13 Installationsdatei von der offiziellen Webseite (jdk.java.net), auf welcher die OpenJDK Dateien von Oracle bereitgestellt werden, herunterladen und danach die Installation von Java 13 mit Hilfe der OpenJDK Daten durchführen.

Im Anschluss an die Installation werden wir eine Änderung an den Systemumgebungsvariablen vornehmen und abschließend mit einer Testanwendung die korrekte Installation des OpenJDK 13 überprüfen.

Hinweis: Wir werden jeden Installationsschritt exakt dokumentieren, so dass auch Programmieranfänger die Installation des OpenJDKs problemlos durchführen können. Für alle Java-Neulinge haben wir außerdem in der Lektion Java auf einem Windows PC installieren den Aufbau des Java Development Kit detailliert beschrieben.

Die Installation von Java 13 (OpenJDK 13) besteht somit aus den folgenden Schritten, die auch gleichzeitig die Kapitel dieser Lektion sind:

1. Download der Installationsdatei des OpenJDK 13 (Java Development Kit)

Android Apps Programmieren Online-Kurs

Unser großes
Android Online-Kurs
Gesamtpaket



Weitere Infos

Beginnen wir nun mit dem ersten Installationsschritt und laden die Installationsdatei des aktuellen Java Development Kit OpenJDK 13 aus dem Internet herunter.

Bevor wir mit dem Download beginnen, möchten wir noch kurz erklären, was das freie OpenJDK von Oracle genau ist und wie es sich vom kommerziellen JDK von Oracle unterscheidet.

Das freie und quelloffene OpenJDK bildet die Referenzimplementierung für die Java Standard Edition. Alle Entwicklungen an der Programmiersprache Java und der Plattform werden dort durchgeführt.

Das OpenJDK wird von Oracle selbst kompiliert und bereitgestellt. Die aktuellen Versionen des OpenJDK sind auf der Webseite jdk.java.net abgelegt. Dort sind die OpenJDK x64-Builds für Windows, Linux und macOS zu finden.

Oracle stellt noch eine weitere Java SE Implementierung zur Verfügung, das Oracle JDK. Dieses unterscheidet sich nur in einigen wenigen Punkten von dem ebenfalls von Oracle bereitgestellten OpenJDK.

Oracle hat sich das Ziel gesetzt, OpenJDK– und Oracle JDK-Binärdateien so identisch wie möglich zu erstellen. Dennoch gibt es für das aktuelle JDK 13 einige Unterschiede zwischen den beiden JDKs.

Die derzeitigen Unterschiede sind:

  • Oracle JDK bietet „Installer“ an, die nicht nur die JDK-Binärdateien in Ihrem System platzieren, sondern auch Update-Regeln enthalten und in einigen Fällen einige gängige Konfigurationen wie das Setzen gemeinsamer Umgebungsvariablen (z.B. JAVA_HOME in Windows) und das Erstellen von Dateiverknüpfungen (z.B. das Starten von .jar-Dateien mit Java) handhaben. OpenJDK wird nur als komprimiertes Archiv (tar.gz oder .zip) angeboten.
  • Der Befehl javac -release für die Release-Werte 9 und 10 verhalten sich unterschiedlich. Oracle JDK-Binärdateien beinhalten APIs, die nicht zu OpenJDK-Binärdateien hinzugefügt wurden, wie z.B. JavaFX, Ressourcenmanagement und (Änderungen vor JDK 11) JFR-APIs.
  • Die Nutzungsaufzeichnung ist nur in Oracle JDK verfügbar.
  • Oracle JDK verlangt, dass kryptografische Drittanbieter mit einem Java Cryptography Extension (JCE) Code Signing Certificate signiert werden. OpenJDK erlaubt weiterhin die Verwendung von unsignierten Krypto-Drittanbietern.
  • Die Ausgabe des Befehls java -version ist unterschiedlich. Oracle JDK gibt Java zurück und enthält den Oracle-spezifischen Bezeichner. OpenJDK gibt OpenJDK zurück und enthält nicht den Oracle-spezifischen Bezeichner.
  • Oracle JDK ist unter der OTN-Lizenz verfügbar. OpenJDK ist unter GPLv2wCP freigegeben. Die mitgelieferten Lizenzdateien sind daher unterschiedlich.
  • Oracle JDK vertreibt FreeType unter der FreeType-Lizenz und OpenJDK unter der GPLv2. Der Inhalt von \legal\java.desktop\freetype.md ist daher anders.
  • Oracle JDK hat Java Cup und Steam Icons und OpenJDK hat Duke Icons.
  • Der Oracle JDK-Quellcode enthält „ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.“ Der mit OpenJDK verteilte Quellcode bezieht sich stattdessen auf die GPL-Lizenzbedingungen.

Aufpassen muss man bei den Lizenzbedingungen:

  • Das OpenJDK von Oracle steht unter der GNU General Public License v2 mit der Classpath Exception (GPLv2+CPE). Es ist kostenlos, quelloffen und kann frei eingesetzt werden.
  • Das JDK von Oracle steht unter eine kommerziellen Lizenz. Somit kann das Oracle JDK nicht kostenlos kommerziell eingesetzt werden. Oracle erlaubt die Nutzung nur für „personal use and development use“ unter bestimmten Umständen. Möchte man das JDK von Oracle kommerziell einsetzen, ist der Erwerb einer Lizenz von Oracle notwendig.

Da die Unterschiede zwischen dem Oracle OpenJDK und dem Oracle JDK nur sehr gering sind, ist es empfehlenswert das freie und quelloffene OpenJDK für die Entwicklung von eigenen Java Anwendungen zu verwenden. Es kann kostenfrei genutzt werden und bildet die Referenzimplementierung der Java Standard Edition. Aus diesen Gründen verwenden wir das OpenJDK auch in unserem Java Kurs als JDK unserer Wahl.

Möchte man jedoch nicht das aktuellste Java Development Kit einsetzen und stattdessen lieber auf eine JDK Version mit Langzeit-Support zurückgreifen, sind die Java Distributionen von Amazon oder AdoptOpenJDK eine sehr gute Wahl. In unserem Beitrag Java Amazon Corretto installieren zeigen wir, wie das Amazon Corretto JDK 8 und JDK 11 auf einem Windows PC installiert wird. In einem weiteren Beitrag zu diesem Thema beschreiben wir, wie die Installation des AdoptOpenJDK unter Windows erfolgt.

Hinweis: In unseren Lektionen Installieren von Oracle JDK 13, Oracle JDK 11 (LTS) und Oracle JDK 8 (LTS) haben wir ausführlich beschrieben, wie die offiziellen JDKs von Oracle installiert werden.

1.1 Herunterladen des OpenJDK 13 von der offiziellen Hersteller-Webseite

Wir werden nun das OpenJDK 13 aus dem Internet herunterladen. Wie wir bereits erfahren haben, wird das OpenJDK von Oracle kompiliert und für mehrere Plattformen bereitgestellt.

Da wir in dieser Lektion das OpenJDK 13 auf einem Windows 10 PC installieren werden, laden wir die OpenJDK-Portierung für Windows 64-Bit herunter. Es werden aber auch Portierungen für andere Betriebssysteme (Linux, macOS) von Oracle bereitgestellt.

Auf folgender Seite kann die aktuelle Version des OpenJDK 13 heruntergeladen werden:

Download-Seite des OpenJDK 13

Auf der verlinkten Download-Seite von Oracle werden verschiedene Portierungen des OpenJDK 13 zum Download bereitgestellt. Es stehen Versionen für folgende Betriebssystem zur Auswahl:

  • Linux (64-Bit)
  • macOS (64-Bit)
  • Windows (64-Bit)

In der unteren Abbildung ist die Download-Seite des OpenJDK 13 dargestellt:

download_openjdk_13_oracle

Download-Bereich der OpenJDK 13 Webseite
(Quelle: https://jdk.java.net/13/ [Stand: Dezember 2019])

Wie in der oberen Abbildung zu erkennen ist, wird das OpenJDK nicht als Installationsprogramm bereitgestellt, sonder nur als komprimierte ZIP-Datei. Dies ist aber völlig unproblematisch, da wir die Installation des OpenJDK manuell durchführen und einen Installer dafür nicht benötigen.

Wir möchten unter Windows 10 (64-Bit) Java Anwendung programmieren, daher ist für uns das OpenJDK mit der Bezeichnung Windows/x64 die richtige Wahl. Die zugehörige ZIP-Datei des OpenJDK laden wir nun herunter.

Der Download-Link ist in der oberen Abbildung mit einer blauen Linie markiert worden und befindet sich direkt hinter Windows/x64 (Markierung A). Wir starten den Download des OpenJDK, indem wir auf den Link zip klicken.

Der Download beginnt sofort und sollte aufgrund der geringen Dateigröße, weiniger als 200 MB, auch nicht sehr lange dauern. Sobald der Download der OpenJDK ZIP-Datei abgeschlossen ist, kann mit der Installation des aktuellen Java Development Kits Programmdateien begonnen werden.

2. Installation des OpenJDK 13 auf einem Windows 10 PC

Die eben heruntergeladene ZIP-Archivdatei enthält die Programmdateien des OpenJDK, also ausführbare Programme wie Compiler und Interpreter sowie die Bibliotheken und Quellcodes des Java Development Kits. Dies kann man auch an ihren Dateinamen erkennen, der wie folgt vergeben wird: openjdk-[version]_[system]_bin.zip

In der unteren Abbildung ist die heruntergeladene ZIP-Archivdatei des OpenJDK 13 zu sehen. Sie ist etwa 190 MB groß und trägt den Dateinamen openjdk-13.0.1_windows-x64_bin.zip (Markierung A):

openjdk_13_datei_in_javakurs_ordner

Die OpenJDK Archivdatei mit Versionsnummer (Build-Nummer)

Die heruntergeladene ZIP-Datei des OpenJDK 13 sollte sich in einem eigenen Ordner auf dem PC befinden. In unserem Fall befindet sich die OpenJDK-Datei in dem vorher erstellten Ordner C:\JavaKurs (Markierung B).

Hinweis: Wir werden in unserem großen Java Online-Kurs alle Projektdateien und JDK-Dateien in dem Ordner C:\JavaKurs organisieren. Alle Kursteilnehmer sollten dies ebenso übernehmen und diesen Ordner auf ihrer Festplatte anlegen, damit die Lerninhalte leichter nachvollzogen werden können.

Das OpenJDK-Archiv müssen wir nun entpacken. Dazu navigieren wir in den Ordner, in welchem die OpenJDK-Archivdatei abgelegt wurde. In unserem Fall haben wir die OpenJDK-Datei in den von uns erstellten Ordner C:\JavaKurs abgelegt. Solltet ihr die Datei in einem anderen Ordner abgelegt haben, müsst ihr zu diesem navigieren.

Um die OpenJDK ZIP-Datei zu entpacken, führen wir nun die folgenden Schritte durch:

  1. Mit der rechten Maustaste auf die Datei openjdk-13.0.1_windows-x64_bin.zip klicken.
  2. Anschließend den Eintrag Alle extrahieren… des Kontext-Menüs anklicken.

openjdk_13_entpacken_in_javakurs_ordner

Entpacken der OpenJDK Programmdateien per Rechtsklick

Als Nächstes öffnet sich der Extraktionsdialog von Windows, welcher uns durch den Extraktionsprozess führt. In diesem Dialog werden wir nun den Namen für den Ordner vorgegeben, in welchen die OpenJDK Programmdateien entpackt werden sollen.

In dem Extraktionsdialog nehmen wir nun folgende Einstellungen vor:

  1. Als Ordnernamen geben wir C:\JavaKurs vor (Markierung A).
  2. Das Häkchen bei „Dateien nach Extrahierung anzeigen“ lassen wir aktiviert.
  3. Anschließend starten wir das Entpacken durch Klick auf den Extrahieren Button.

openjdk_13_ordnername_vorgeben

Wir geben den Ordner vor, in welchen die OpenJDK Dateien extrahiert werden sollen

Windows beginnt nun mit dem Entpacken der OpenJDK Programmdateien in den vorgegebenen Ordner (in unserem Fall C:\JavaKurs). In diesen Ordner werden die Dateien nicht direkt entpackt, sondern in einem Unterordner darin abgelegt.

Der Pfad des Unterordners lautet C:\JavaKurs\jdk-13.0.1. In diesem Ordner befinden sich alle Dateien des OpenJDK 13.

Wir werden diesen Unterordner nun umbenennen, so dass wir später leichter auf ihn zugreifen können. Dazu führen wir die folgenden Schritte aus:

  1. Mit der rechten Maustaste auf den Ordner jdk-13.0.1 klicken.
  2. Anschließend den Eintrag Umbenennen des Kontext-Menüs anklicken.
  3. Als neuen Namen für den Unterordner geben wir openjdk-13 ein.

openjdk_13_unterordner_umbenennen

Den beim Extrahieren erstellten OpenJDK-Ordner geben wir einen passenderen Namen

Als neuen Namen für den Ordner, in welchem sich die extrahierten OpenJDK Dateien befinden, geben wir openjdk-13 ein. Durch diesen neuen Ordnernamen wird sofort ersichtlich, dass sich die OpenJDK 13 Programmdateien darin befinden.

In der unteren Abbildung ist der Ordner bereits umbenannt worden und trägt den neuen Ordnernamen openjdk-13 (Markierung A):

openjdk_13_unterordner_umbenannt

Der Ordner mit den OpenJDK Dateien trägt nun den Namen openjdk-13

Wir haben nun die Installation des OpenJDK 13 und somit auch der Java 13 Standard Edition auf unserem Windows 10 Rechner abgeschlossen.

Als Nächstes möchten wir die OpenJDK Installation überprüfen. Doch bevor wir mit der Überprüfung beginnen, ist es sinnvoll, noch einen kurzen Blick auf den Inhalt des eben entpackten OpenJDK Ordners zu werfen.

2.1 Der Inhalt des OpenJDK 13 Ordners

Wir werden nun die Ordnerstruktur des eben entpackten OpenJDK Ordners genauer betrachten. Das wichtigste Unterverzeichnis /bin enthält die JDK-Werkzeuge, die für das Kompilieren und Ausführen von Java Anwendungen benötigt werden.

In der unteren Abbildung ist der Inhalt des OpenJDK Verzeichnisses dargestellt. Es ist zudem der absolute Pfad des OpenJDK Ordners (Markierung A) zu erkennen:

openjdk_13_ordnerstruktur

Die Ordnerstruktur des entpackten OpenJDK Ordners

  • bin – In diesem Unterordner befinden sich Entwicklungswerkzeuge des OpenJDK 13. Besonders wichtig sind bspw. der Java-Interpreter java.exe und der Java-Compiler javac.exe.
  • conf – Hier befinden sich wichtige Konfigurationsdateien.
  • include – Enthält Werkzeuge für die Anbindung von Java an C und C++ Programme.
  • jmods – Wichtige Java-Module des OpenJDKs, bspw. das Basis-Modul.
  • legal – Dieser Ordner enthält wichtige Lizenzangaben.
  • lib – Enthält interne JDK-Werkzeuge und auch das Archiv src.zip mit dem Quellcode der öffentlichen Java-Bibliotheken.
  • release – Datei mit Schüssel-Wert-Paaren mit Infos über das OpenJDK Release.

Wir haben nun den Inhalt des eben entpackten OpenJDK Ordners und dessen Struktur kennengelernt. Als Nächstes möchten wir die OpenJDK Installation mit Hilfe der Windows Eingabeaufforderung überprüfen.

2.2 Überprüfen der OpenJDK Installation

Ob die Installation des OpenJDK 13 fehlerfrei erfolgt ist, können wir sehr schnell mit Hilfe der Windows Eingabeaufforderung überprüfen.

Dazu öffnen wir nun die Eingabeaufforderung folgendermaßen:

  1. Zuerst drücken wir die Windows-Taste und geben danach den Begriff Eingabeaufforderung als Suchbefehl ein.
  2. Danach klicken wir auf den oberen Eintrag Eingabeaufforderung.

openjdk_13_eingabeaufforderung_starten

Öffnen der Windows 10 Eingabeaufforderung

Es öffnet sich nun die Windows Eingabeaufforderung in einem kleinen Fenster.

In der Eingabeaufforderung werden wir nun die OpenJDK Installation testen. Dazu müssen wir in das /bin Verzeichnis des OpenJDK Ordners navigieren, welches in unserem Fall folgenden absoluten Pfad C:\JavaKurs\openjdk-13\bin besitzt.

Zu diesem Pfad werden wir nun mit den Befehlen cd.. (einen Ordner nach unten navigieren) und cd Ordnername (den angegebenen Ordner betreten) navigieren. Die Abkürzung cd steht für change directory, also für Verzeichnis wechseln.

In der unteren Abbildung ist zu erkennen, wie wir in das /bin Verzeichnis des OpenJDK Ordners (Markierung A) navigiert sind:

openjdk_13_in_jdk_ordner_navigieren

In das bin-Verzeichnis des OpenJDK Ordners navigieren

In dem /bin Verzeichnis des OpenJDK Ordners befinden sich die ausführbaren Dateien des Java Development Kits. Für uns sind die beiden Dateien java.exe und javac.exe von besonderer Bedeutung.

Mit der ausführbaren Datei java.exe werden Java Programme gestartet und in der Java Laufzeitumgebung (Java Runtime Environment), einer virtuellen Maschine, ausgeführt.

Mit der anderen ausführbaren Datei javac.exe werden Java Quelltexte in Java Bytecode übersetzt. In Bytecode übersetzte Dateien tragen die Endung .class und können in der Java Laufzeitumgebung ausgeführt werden.

Wir werden nun in der Eingabeaufforderung diese beiden Dateien ausführen und uns dabei die Version des installierten OpenJDKs ausgeben lassen.

Dazu geben wir nun folgende Befehle in der Eingabeaufforderung ein:

  1. Mit dem Befehl java.exe -version werden Informationen über die installierte Java Laufzeitumgebung (Runtime Environment) ausgegeben.
  2. Mit dem Befehl javac.exe -version wird die Version des Java Compilers auf der Kommandozeile ausgegeben.

In der unteren Abbildung wurden die beiden Befehle bereits eingegeben:

openjdk_13_installation_testen

Mittels java.exe und javac.exe überprüfen wir, ob das OpenJDK korrekt installiert wurde

Mit den oben beschriebenen Befehlen java.exe -version (Markierung A) und javac.exe -version (Markierung B) lassen wir uns wichtige Informationen über das installierte OpenJDK auf der Kommandozeile ausgeben.

Wie zu erkennen ist, wurde das OpenJDK (Java) Runtime Environment und der Java Compiler der Version 13.0.1 erfolgreich auf unserem Windows 10 PC installiert.

Somit haben wir nun das OpenJDK 13 auf unserem PC installiert, dessen Ordnerstruktur näher kennengelernt und es auf Funktion getestet. Es ist nun möglich Java Anwendungen zu erstellen, zu kompilieren und auszuführen.

Jedoch wäre dies momentan noch etwas unkomfortabel, da wir beim Kompilieren und Ausführen mit den absoluten Pfadangaben zur OpenJDK-Installation arbeitet müssten.

Um dies komfortabler zu gestalten, werden wir als Nächstes den Pfad zu dem /bin Ordner der OpenJDK-Installation in die Windows Umgebungsvariable Path eintragen. Dadurch wird es möglich sein Java Quelldateien ohne Angabe des absoluten Pfads zu kompilieren und auszuführen.

3. Eintragen des Pfads zur OpenJDK-Installation in die Windows Umgebungsvariable Path

Windows 10 verwendet eine Umgebungsvariable mit dem Namen Path. In dieser Variable wird eine Liste von Verzeichnissen verwaltet, in denen das Betriebssystem nach ausführbaren Programmen sucht, wie bspw. dem Java Compiler.

Die Umgebungsvariable Path ist also der Suchpfad mit dessen Hilfe die Windows Eingabeaufforderung (auch Windows Shell, Kommandozeile oder Konsole genannt) nach ausführbaren Programmdateien sucht.

Ist das /bin Verzeichnis, welches sich im OpenJDK-Installationsordner befindet, in den Suchpfad für ausführbare Dateien (Path) eingetragen, dann können wir bspw. den Java Compiler javac.exe und die Java Laufzeitumgebung java.exe von jedem beliebigen Verzeichnis aus ausführen.

Denn das Betriebssystem kennt ja Dank der Path Umgebungsvariable den Pfad zu den ausführbaren Dateien javac.exe und java.exe.

Wenn die Systemvariable Path nicht entsprechend gesetzt ist, muss immer der vollständigen Pfad zum Java Compiler angeben werden, um diesen auszuführen. Dies würde dann in der Windows Eingabeaufforderung so aussehen:

C:\>C:\JavaKurs\openjdk-13\bin\java.exe -version

Da es in der Praxis sehr umständlich ist, bei jedem Compiler-Aufruf immer den kompletten Pfad zur OpenJDK-Installation anzugeben, ist es sinnvoll den Suchpfad zu erweitern. Dazu muss der OpenJDK-Pfad permanent in der Systemvariable Path gespeichert werden.

plhq_teaser_hbox_gelb_fotolia_RA Studio_46292813

Unser großes
Android Online-Kurs
Gesamtpaket



Weitere Infos

Um den OpenJDK-Pfad permanent zu hinterlegen, muss der vollständige Pfad des /openjdk-13/bin Ordners in die Systemvariable Path eingetragen werden. In unserem Fall sieht der vollständige Pfad folgendermaßen aus:

C:\JavaKurs\openjdk-13\bin

Diesen Pfad tragen wir nun mit den folgenden Schritten in die Windows 10 Systemvariable Path ein:

  1. Zuerst drücken wir die Windows-Taste und geben danach den Begriff Systemumgebungsvariablen als Suchbefehl ein.
  2. Danach klicken wir auf den oberen Eintrag Systemumgebungsvariablen bearbeiten, woraufhin sich der Systemeigenschaften-Dialog öffnet.

openjdk_13_systemumgebungsvariablen_bearbeiten

Mit Hilfe des Suchfelds die Systemumgebungsvariablen bearbeiten

Nun öffnet sich der Systemeigenschaften-Dialog, in welchem bereits der Erweiter-Tab aktiv ist.

Wir klicken nun auf den Umgebungsvariablen… Button ganz unten:

openjdk_13_umgebungsvariablen_bearbeiten

Im Systemeigenschaften-Dialog den Umgebungsvariablen Button klicken

Danach öffnet sich der Umgebungsvariablen-Dialog von Windows 10. Hier können Benutzervariablen für den angemeldeten Benutzer und Systemvariablen erstellt und bearbeitet werden. Für uns sind die Systemvariablen wichtig.

Wir wählen nun die Systemvariable Path aus und klicken anschließend auf den Bearbeiten… Button:

openjdk_13_systemvariablen_setzen

Im Umgebungsvariablen-Dialog bearbeiten wir die Systemvariable Path

Nun öffnet sich der Umgebungsvariable bearbeiten-Dialog, welcher uns alle eingetragenen Verzeichnispfade des Suchpfads übersichtlich anzeigt.

Um den Pfad zum /bin Verzeichnis der OpenJDK-Installation einzufügen, klicken wir nun auf den Neu Button:

openjdk_13_java_pfad_anlegen

Eine neue Pfadangabe der Systemvariable Path hinzufügen

Am Ende der Pfadliste erscheint nun ein neuer leerer Eintrag. In dieses Feld geben wir nun den Pfad zum /bin Ordner der OpenJDK-Installation ein.

In unserem Fall tragen wir nun C:\JavaKurs\openjdk-13\bin am Ende der Liste ein:

openjdk_13_java_pfad_eingetragen

Wir haben den Pfad C:\JavaKurs\openjdk-13\bin in den Suchpfad eingetragen

Wie in der oberen Abbildung zu erkennen ist, haben wir am Ende der Suchpfad-Liste den Eintrag C:\JavaKurs\openjdk-13\bin (Markierung A) hinzugefügt. Wenn ihr alle Arbeitsschritte dieser Lektion exakt befolgt habt, sollte dies auch bei euch der Pfad zum /bin Verzeichnis der OpenJDK-Installation sein.

Um den hinzugefügten Pfad fest in die Systemvariable Path einzutragen, müssen nun noch alle geöffneten Systemsteuerungs-Dialoge mit jeweils einem Klick auf den OK Button bestätigt werden. Dadurch wird der Suchpfad um den hinzugefügten Eintrag erweitert.

Wir haben nun den Pfad zu dem /bin Ordner der OpenJDK-Installation in die Windows Umgebungsvariable Path eingetragen.

Habt ihr das OpenJDK in einen anderen Ordner installiert, muss dies bei der Angabe des Suchpfads beachtet werden. Welcher Pfad es bei euch ist, könnt ihr mit Hilfe des Windows Datei Explorers herausfinden.

Navigiert dazu in das /bin Verzeichnis eurer OpenJDK-Installation und klickt in das Feld des angezeigten Verzeichnispfads (Markierung A):

openjdk_13_path_ordner

Der Pfad zum bin-Verzeichnis des OpenJDK Ordners kann vom Datei Explorer angezeigt werden

Kopiert nun den angezeigten Pfad und fügt ihn in die Systemumgebungsvariable Path, so wie oben beschrieben, ein.

3.1 Überprüfen der Umgebungsvariable Path und OpenJDK-Installation

Wir werden nun überprüfen, ob der OpenJDK-Pfad korrekt in die Umgebungsvariable Path eingetragen wurde. Hierfür ist es unbedingt erforderlich die Eingabeaufforderung komplett neu zu starten, da nur in einer neu gestarteten Eingabeaufforderung der aktuellste Path verwendet.

Wir starten nun die Eingabeaufforderung komplett neu:

  1. Zuerst drücken wir die Windows-Taste und geben danach den Begriff Eingabeaufforderung als Suchbefehl ein.
  2. Danach klicken wir auf den oberen Eintrag Eingabeaufforderung.

openjdk_13_eingabeaufforderung_starten

Öffnen der Windows 10 Eingabeaufforderung

Es öffnet sich nun die Windows Eingabeaufforderung ganz neu in einem kleinen Fenster. Durch das Neustarten haben wir sichergestellt, dass sie die aktuellsten Einträge der Umgebungsvariable Path verwendet.

Wir möchten uns nun den Inhalt der Umgebungsvariable Path ausgeben lassen. Zudem möchten wir von einem beliebigen Ordner aus auf die ausführbaren Dateien java.exe und javac.exe zugreifen, um zu überprüfen, ob diese Dateien mit Hilfe des von uns erweiterten Suchpfads gefunden werden.

Dazu geben wir nun folgende Befehle in der Eingabeaufforderung ein:

  1. Mit der Eingabe path lassen wir den Inhalt des Suchpfads ausgeben, in welchen wir den Pfad zum /bin Ordner der OpenJDK-Installation eingetragen haben.
  2. Mit dem Befehl java.exe -version prüfen wir, ob die ausführbare Datei java.exe mit Hilfe des von uns erweiterten Suchpfads gefunden wird.
  3. Mit dem Befehl javac.exe -version prüfen wir, ob auch die javac.exe Datei mittels Suchpfad gefunden wird.

In der unteren Abbildung wurden alle drei Befehle bereits eingegeben:

openjdk_13_ordner_in_path_eingetragen

Prüfen, ob der OpenJDK-Path korrekt gesetzt wurde und auf die ausführbaren Java Dateien zugegriffen werden kann

Mit dem Befehle path lassen wir den Inhalt der Systemumgebungsvariable Path ausgeben. Wie zu erkennen ist, enthält diese den von uns vorher eingefügten JDK-Path (Markierung A).

Mit den anderen beiden Befehlen java -version und javac -version lassen wir uns Informationen über die Versionen der Java Laufzeitumgebung und des Java Compilers ausgeben. Gleichzeitig prüfen wir dadurch, ob beide Dateien mit Hilfe des Windows Suchpfads gefunden werden, da wir auf die Dateien von einem beliebigen Verzeichnis aus zugreifen (hier von Verzeichnis C:\ aus).

Wurden alle drei Befehle wie oben beschrieben ausgeführt, ist die Installation von Java 13 erfolgreich auf dem Windows 10 PC durchgeführt worden. Wir können nun mit dem Programmieren eigener Java Anwendungen beginnen. Dies werden wir im letzen Kapitel dieser Lektion mit einer einfachen Java Testanwendung auch tun.

plhq_teaser_hbox_gelb_fotolia_RA Studio_46292813

Unser großes
Android Online-Kurs
Gesamtpaket



Weitere Infos

Achtung: Damit vorgenommene Änderungen an der Systemumgebungsvariable Path wirksam werden, muss die Eingabeaufforderung neu geöffnet werden. Manchmal ist auch ein Neustart des Betriebssystems erforderlich.

Weiter Hinweise bzgl. der Systemvariable Path:

  • Die Systemvariable Path besteht aus einer Reihe von Verzeichnissen, die durch Semikolons voneinander getrennt sind.
  • Sie ist nicht case-sensitive und wird von Windows in der Reihenfolge von links nach rechts betrachtet.
  • Es sollte nur ein /bin-Ordner der OpenJDK-Installation eingetragen sein. Die anderen folgenden werden ignoriert.
  • Der Suchpfad sollte an das Ende Systemvariable Path eingetragen werden.
  • Erst durch Öffnen einer neuen Eingabeaufforderung treten Änderungen der Systemvariable Path in Kraft.

4. Programmieren einer einfachen Java Test-Anwendung

Wir haben nun das Java Development Kit erfolgreich installiert und auch den Pfad zur OpenJDK-Installation in die Umgebungsvariable Path eingetragen. Somit ist Java 13 einsatzbereit. Wir möchten nun das OpenJDK 13 das erste Mal verwenden und unser erstes kleines Java Programm schreiben.

Dazu werden wir folgende Schritte ausführen:

  1. Erstellen einer Quelldatei (source file): Eine Quelldatei enthält den Quelltext. Dieser ist in der Programmiersprache Java geschrieben. Der Quelltext kann von anderen Programmierern verstanden werden. Die Quelldatei wird mit einem Texteditor erstellt und auch verändert.
  2. Kompilieren der Quelldatei: Das Übersetzen des Quelltextes in Anweisungen die von der Java Virtuellen-Maschine verstanden werden, wird als Kompilieren bezeichnet. Dieser Prozess wird von dem Java Compiler javac.exe durchgeführt und als Ergebnis erhält man eine .class Datei die Java Bytecode enthält.
  3. Ausführen des Java-Programms: Die erstellte .class Datei wird mit Hilfe des Java Interpreters java.exe aufgerufen und ausgeführt. Als Ergebnis wird eine Meldung auf dem Bildschirm ausgegeben.

4.1 Erstellen einer Java Quelldatei (source file)

Für das Erstellen einer Java Quelldatei wird ein normaler Texteditor, bspw. der Editor von Windows 10, benötigt.

Hinweis: Es ist nicht möglich Java Quelltexte mit Word zu schreiben, da eine Textverarbeitung zusätzliche Sonderzeichen in den Quellcode einfügt und dadurch unser Java Programm fehlerhaft würde. Daher muss unbedingt ein reiner Texteditor verwendet werden.

Wir öffnen nun den Windows Editor wie folgt:

  1. Zuerst drücken wir die Windows-Taste und geben danach den Begriff Editor als Suchbefehl ein.
  2. Danach klicken wir auf den oberen Eintrag Editor.

openjdk_13_editor_starten

Den Editor von Windows über das Suchfeld starten

Es öffnet sich der Editor in einem eigenen Fenster.

Wir kopieren nun den unteren Quelltext und fügen diesen in den Editor ein:

HelloWorld.java

public class HelloWorld 
{
  public static void main(String[] args) 
  {
    System.out.println("Hello ProgrammierenLernenHQ World.");
  }
}

Der obere Quelltext enthält die Definition der Klasse HelloWorld mit der statischen main() Methode. Die main() Methode enthält das Hauptprogramm unserer Java Anwendung. Durch sie lassen wir einen kurzen Gruß, die „Hallo Welt“ Botschaft, ausgeben.

Falls ihr den oberen Quellcode selbst eingeben möchtet, achtet bitten unbedingt darauf nur den Text zu übernehmen und nicht auch die Zeilennummern.

Hinweis: Alle Variablen, Anweisungen und Dateinamen müssen wie angegeben geschrieben werden. Der Java Compiler javac.exe und der Java Interpreter java.exe sind beide case sensitive. Dies bedeutet, dass für Java ein Unterschied zwischen der Klasse HelloWorld und helloworld besteht. Daher muss immer genau auf die Groß- und Kleinschreibung geachtet werden. Weiterhin muss die Hauptklasse und der Dateiname identisch sein. In unserem Beispiel heißt unsere Hauptklasse HelloWorld. Daher muss die Quelltext-Datei HelloWorld.java heißen.

Im Editor sieht die Quelldatei HelloWorld.java dann folgendermaßen aus:

openjdk_13_editor_java_quelltext

Der Quelltext unserer ersten Java Anwendung wurde im Editor eingefügt

Jetzt müssen wir die Quelldatei unter dem Dateinamen HelloWorld.java abspeichern. Es muss exakt dieser Dateiname sein, da er mit dem Namen der von uns definierten Java Klasse HelloWorld übereinstimmen muss.

Um die Quelldatei zu speichern, öffnen wir nun den Speichern unter-Dialog:

  1. Zuerst klicken wir in der oberen Menüleiste des Editors auf den Datei Eintrag.
  2. Anschließend klicken wir auf den Speichern unter… Eintrag des Kontext-Menüs.

openjdk_13_editor_speichern_unter

Wir öffnen den Speichern unter-Dialog des Editors

Es öffnet sich nun der Speichern unter-Dialog des Editors, der uns beim Speichern der Java Quelldatei unterstützt. Das Abspeichern ist ein kritischer Schritt, da der Dateiname unbedingt korrekt vorgegeben werden muss.

Wir speichern nun die Quelldatei folgendermaßen ab:

  1. Zunächst wählen wir als Speicherort den Ordner C:\JavaKurs aus.
  2. Anschließend geben wir den Dateinamen HelloWorld.java ein.
  3. Als Dateityp wählen wir den Eintrag Alle Dateien (*.*) aus.
  4. Den Dialog bestätigen wir einem Klick auf den Speichern Button.

openjdk_13_editor_quelltext_speichern

Den Java Quelltext speichern wir in der Datei HelloWorld.java ab

Mit einem Klick auf den Speichern Button wird die Quelldatei HelloWorld.java in dem ausgewähltem Verzeichnis, in unserem Fall C:\JavaKurs, gespeichert.

4.2 Kompilieren der Quelldatei

Als Nächstes werden wir die eben abgespeicherte Quelldatei HelloWorld.java mit Hilfe des Java Compilers kompilieren lassen. Dabei wird der Java Quelltext in Java Bytecode übersetzt. Das Kompilieren werden wir in der Eingabeaufforderung durchführen.

Wir öffnen nun erneut die Eingabeaufforderung, wie hier beschrieben. Anschließend navigieren wir in das Verzeichnis, in welchem die Quelldatei abgespeichert wurde. In unserem Fall befindet sich die HelloWorld.java Datei in dem Ordner C:\JavaKurs.

Mit dem Befehl dir kann der Inhalt des Ordners ausgegeben werden. Dies ist in der unteren Abbildung dargestellt:

openjdk_13_dir_befehl

In das Verzeichnis mit der Quelldatei HelloWorld.java navigieren

Wie anhand der oberen Abbildung zu erkennen ist, befindet sich die HelloWorld.java Datei (Markierung A) in dem C:\JavaKurs Ordner. Somit können wir mit dem Übersetzen (Kompilieren) der Java Quelldatei beginnen.

Das Kompilieren starten wir nun mit folgendem Befehl:

javac.exe HelloWorld.java

Der Java Compiler beginnt sofort mit dem Kompilieren. Dabei übersetzt er den Quelltext in Java Bytecode und speichert diesen in der neuen Datei HelloWorld.class im gleichen Verzeichnis ab.

Es sollten sich nun zwei HelloWorld-Dateien in dem Verzeichnis befinden:

  • Die Java Quelldatei: HelloWorld.java
  • Die Java Bytecode-Datei: HelloWorld.class

openjdk_13_java_kompilieren

Die Java Quelldatei wurde kompiliert in die Bytecode Datei HelloWorld.class

In der oberen Abbildung ist zum einen der Kompilierbefehl (Markierung A) und zum anderen die kompilierte Java Bytecode Datei HelloWorld.class (Markierung B) zu erkennen.

Da wir jetzt die .class Datei erzeugt haben, können wir als Nächstes unser erstes Java Programm starten!

4.3 Ausführen der selbst programmierten Java Anwendung

Um die kompilierte Java Bytecode Datei HelloWorld.class auszuführen, wird der Java Interpreter java.exe verwendet. Der Aufruf erfolgt in dem Ordner, in welchem sich die kompilierte Datei befindet.

Wir werden nun mit folgendem Befehl unsere Java Anwendung ausführen:

java.exe HelloWorld

Achtung! Die Endung .class darf nicht mit angegeben werden.

Häufig gibt der Java-Interpreter die Fehlermeldung „NoClasDefFoundError“ aus. Gründe dafür sind:

  • Der Name der Klasse ist falsch geschrieben.
  • Es ist keine main() Methode vorhanden.
  • Die main() Methode ist nicht korrekt deklariert.
  • Die Endung .class wurde mit angegeben.

Unsere Java 13 Test-Anwendung sollte nun starten und in der Eingabeaufforderung die Meldung „Hello ProgrammierenLernenHQ World.“ ausgeben.

Hat alles korrekt funktioniert, sollte die Ausgabe wie folgt aussehen:

openjdk_13_java_ausführen

Die Java Bytecode Datei von dem Java Interpreter java.exe ausführen lassen

Wenn der oben abgebildete Text auch bei euch ausgegeben wird, ist das OpenJDK 13 richtig installiert und euer erstes Java Programm funktioniert korrekt.

Herzlichen Glückwunsch!!!

Mit folgenden Links gelangt ihr zurück zu unserem großen Java Online-Kurs oder zurück zur übergeordneten Lektion Wie installiere ich Java.


Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.