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:

Inhalte dieser Lektion

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

---

Unser großes
Android Online-Kurs
Gesamtpaket

---

Ideal für den praxisnahen Einstieg in die Entwicklung von Android Apps Besonders einsteigerfreundlich - jeder Schritt ist exakt dokumentiert Alle 35 Lektionen unseres Android Apps Programmieren Kurses Alle 8 Lektionen unseres SQLite App Programmieren Kurses

---

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.

Die Unterschiede zwischen Oracle OpenJDK und Oracle JDK im Detail

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:

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:

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):

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.

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.

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.

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):

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:

• 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.

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:

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:

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.

---

Unser großes
Android Online-Kurs
Gesamtpaket

---

Ideal für den praxisnahen Einstieg in die Entwicklung von Android Apps Besonders einsteigerfreundlich - jeder Arbeitsschritt ist exakt dokumentiert Enthält alle 35 Lektionen unseres Android Apps Programmieren Kurses Enthält alle 8 Lektionen unseres SQLite Datenbank App Programmieren Kurses

---

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.

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

Wir klicken nun auf den Umgebungsvariablen… Button ganz unten:

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:

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:

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:

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.

Wenn ihr das OpenJDK in einen anderen Ordner installiert habt

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.

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:

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.

---

Unser großes
Android Online-Kurs
Gesamtpaket

---

Ideal für den praxisnahen Einstieg in die Entwicklung von Android Apps Besonders einsteigerfreundlich - jeder Arbeitsschritt ist exakt dokumentiert Enthält alle 35 Lektionen unseres Android Apps Programmieren Kurses Enthält alle 8 Lektionen unseres SQLite Datenbank App Programmieren Kurses

---

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.

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:

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.

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.

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:

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

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:

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.