JavaFX: Installation / erste Applikation

JavaFX Serie

Übersicht über JavaFX

JavaFX ist ein relativ modernes Framework zur Erstellung von graphischen Oberflächen. Bis einschließlich Java 8 war es Bestandteil vom Java Developer Kit (JDK). Mit Version 9 vom JDK wurde es jedoch ausgelagert und separat als openjfx weiter entwickelt.

Unterschied zu Swing

Ein wichtiger Unterschied zu Swing ist, dass eine Oberfläche in einem separaten File beschrieben werden kann statt diese in Java selbst zusammen zu stellen (deklarative Oberfläche im Gegensatz zu der programmierten Oberfläche).

Desweiteren bietet JavaFX einige technische Aspekte wie z.B. das Binding von Controls an Modelle.

Installation

Das es nicht mehr fester Bestandteil von Java ist, muss man hier manuell eingreifen. Dazu gibt es drei Möglichkeiten:

  1. Eigenständige Installation – dabei muss aber alles korrekt konfiguriert werden, so man kein OpenJDK mit integriertem JavaFX bekommt.
  2. Einbinden in das (Maven oder Gradle) Projekt als Abhängigkeit. Dann ist keine eigenständige Installation notwendig.

Um es hier möglichst einfach nachvollziehbar zu halten, gehe ich hier nur auf die Lösung über Gradle ein. Zum Nachvollziehen empfehle ich die Installation eines JDK in der Version 11 (LTS) oder 14 (aktuelle Version) – z.B. AdoptOpenJDK.
Desweiteren beschreibe ich die Schritte innerhalb von JetBrains IntelliJ Community Edition. Es sollte aber unproblematisch sein, die Vorgehensweise auch auf anderen Entwicklungsumgebungen wie Eclipse oder Netbeans nach zu vollziehen. Diese Entwicklungsumgebungen sind alle für die üblichen Betriebssysteme (Windows, Mac, Linux) verfügbar.

Ich werde im Folgenden aber nur den IntelliJ Weg näher beschreiben. Dazu setze ich derzeit die Version 2020.1 ein.

Ein erstes Gradle Projekt

Um ein neues Projekt zu erstellen, wählen wir „Create New Projekt“ im Start-Dialog von IntelliJ oder im Menü File -> New -> Project.. Nun zeigt uns IntelliJ ein Fenster, bei dem wir Links die Projekt-Technology wählen können und Links Optionen zu dem Projekt auswählen können:

Hier wählen wir Links Gradle aus und stellen sicher, dass Java auf der rechten Seite ausgewählt ist.

Nach „Next“ dürfen wir

  • Einen Namen vergeben. Hier wählen wir JavaFX Test.
  • Das Verzeichnis wird automatisch angepasst. Wenn uns der Ort für das Projekt nicht zusagt, dann können wir den Pfad anpassen.

Hinter Artifact Coordinates versteckt können wir nun noch angeben, unter welchem Namen unser Projekt bekannt sein soll. Diese Informationen umfassen:

  • GroupID, dies ist in der Regel eine Domain des Unternehmens nur umgedrehte Teile, also z.B. de.kneitzel 
  • Artifact ID, die ist sozusagen der interne Name
  • Version, die wir derzeit entwickeln. Während der eigentlichen Entwicklung ist in der Regel ein -SNAPSHOT angehängt.

Nach einem Click auf „Finish“ können wir uns die erzeugte Verzeichnisstruktur ansehen:

Gradle Projektdateien

  • build.gradle ist die Projektbeschreibung
  • settings.gradle enthält Gradle Einstellungen
  • .gradle ist ein Verzeichnis, das Dateien von Gradle zwischen speichern kann.

Gradle Wrapper

Der Gradle Wrapper ist ein kleines Tool, das es uns erlaubt, automatisch die richtige Gradle-Version innerhalb des Projekts herunter zu laden und aufzurufen.

  • gradlew und gradlew.bat sind Startscripte, mit denen wir Gradle starten können.
  • gradle/wrapper – dieses Verzeichnis enthält die Konfiguration für den Gradle Wrapper.

Unser Code

Zu guter letzt haben wir Verzeichnisse für unsere Arbeit:

  • src/main/java und src/test/java enthält unseren Java Code.
  • src/main/resources und src/test/resources enthalten Resourcendateien

JavaFX Abhängigkeit

Damit unser Gradle-Projekt ein JavaFX Projekt wird, müssen wir einige Anpassungen in der build.gradle Datei vornehmen:

plugins

In den Plugins ist bisher nur da Plugin Java aufgeführt. Dies ändern wir auf:

plugins {
id 'application'
id 'org.openjfx.javafxplugin' version '0.0.8'
}

Als nächstes müssen wir angeben, welche JavaFX Module wir verwenden wollen. Dazu fügen wir unterhalb der Plugins ein:

javafx {
version = "11.0.2"
modules = [ 'javafx.controls', 'javafx.fxml' ]
}

Wichtig: Falls statt Java 11 Java 14 eingesetzt wird, bitte die Version von „11.0.2“ auf „14“ ändern.

Bei den Dependencies tragen wir noch zusätzlich die Abhängigkeit zu den javafx.controls und javafx-fxml ein, so dass die Dependencies wie folgt aussehen:

dependencies {
compile group: 'org.openjfx', name: 'javafx-controls', version: '11.0.2'
compile group: 'org.openjfx', name: 'javafx-fxml', version: '11.0.2'
testCompile group: 'junit', name: 'junit', version: '4.12'
}

Erneut gilt: Bei Java 14 bitte die 11.0.2 durch 14 ersetzen.

Zuletzt fehlt noch ein Eintrag, der angibt, welches die Hauptklasse unserer Anwendung werden soll:

mainClassName = 'helloworld.HelloWorld'

Diesen Eintrag können wir unterhalb der „group“ und „version“ Zeile einfügen.

Nach dem Speichern dieser Projekt-Änderungen muss IntelliJ die Änderungen einlesen. Dazu öffnen wir über View -> Tool Windows -> Gradle das Gradle Fenster in IntelliJ und drücken in der Symbolleiste gleich auf das erste Symbol mit den zwei Pfeilen im Kreis: Reload All Gradle Projects

IntelliJ / Gradle laden nun die fehlenden Dateien aus dem Internet nach. Dies sind jetzt vor allem die angegebenen Plugins.

Unser erstes Hello World Programm

Nun müssen wir natürlich noch unser Programm schreiben. Den Namen der Klasse haben wir schon vorgegeben: helloworld.HelloWorld, d.h. wir schreiben eine neue Klasse HelloWorld in dem Package helloworld.

Dazu klicken wir mit der rechten Maustaste auf das blaue java Verzeichnis src/main/java und wählen New -> Java Class.

Als Namen für die Klasse geben wir helloworld.Helloworld ein so dass IntelliJ uns einen Rahmen für unsere Klasse erstellt. Den Inhalt der Datei ersetzen wir mit folgendem ersten JavaFX Code von uns:

package helloworld;

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;

public class HelloWorld extends Application {
public static void main(String[] args) {
launch(args);
}

@Override
public void start(Stage primaryStage) {
primaryStage.setTitle("Hello World!");
StackPane root = new StackPane();
primaryStage.setScene(new Scene(root, 300, 250));
primaryStage.show();
}
}

Starten unseres Programmes

Zum Starten gehen wir erneut in das gradle Toolfenster (Evtl. ist es noch am Rand sichtbar, so dass wir nicht erst über das View Menü gehen müssen) und wählen dort im Fenster in der Baumstruktur:

Tasks -> Application -> run

Und machen ein Doppelclick auf run.

IntelliJ sollte nun unseren Code übersetzen und nach kurzer Zeit unser erstes Programm starten:

Herzlichen Glückwunsch! Auch wenn das erste Programm nach nichts aussieht haben wir einen ersten großen Schritt gemeistert: Wir konnten ein JavaFX Programm schreiben, übersetzen und ausführen. Und das mit ein paar einzelnen, einfachen Schritten.

Sollte es bei der Erstellung der Dateien Probleme gegeben haben, so findet man eine Version unter https://github.com/kneitzel/blog-javafx-series im Verzeichnis „01 helloworld“

Links

Edit

  • 2020-07-03 Wechsel zu einem Repository für die ganze Serie.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.