Überblick der Neuerungen in JavaFX

JavaFX 8 – Was ist neu?

Hendrik Ebbers

©Shutterstock.com/roroto12p

Mit Java 8 hält auch JavaFX 8 als UI-Toolkit Einzug in die Java-Landschaft. Das Toolkit lag bereits seit einiger Zeit in der Version 2.x vor und konnte so in erste Java-6- und Java-7-Anwendungen integriert werden. Mit Version 8 ist JavaFX nun offiziell das empfohlene UI-Toolkit für Java. Dieser Artikel soll die Neuerungen in JavaFX und dessen Integration in das aktuelle JRE genauer vorstellen.

Neben Lambdas ist sicherlich einer der großen Neuerungen in Java das JavaFX-UI-Toolkit, das mit Java 8 als empfohlenes UI-Toolkit mit ausgeliefert wird. JavaFX ist hierbei sowohl im JDK als auch im JRE zu finden. Mit Java 8 liegt JavaFX zwar noch in einem eigenen JAR, dem jfxrt.jar, es wird aber standardmäßig zum Classpath hinzugefügt und kann somit problemlos für das Erstellen von Java-Anwendungen genutzt werden.

Mit Java 8 hält auch die neue Version JavaFX 8 Einzug, die das zuvor mit Java 7 ausgelieferte JavaFX 2.x ablöst. Gegenüber der 2er Version bringt JavaFX 8 einige neue Features mit, die in diesem Artikel einmal vorgestellt werden sollen. Aufgrund der Menge an Änderungen bzw. Erweiterungen zwischen JavaFX 2 und 8 werden hier allerdings nur die Hauptneuerungen vorgestellt. Neben diesen gibt es noch eine Fülle an weiteren zusätzlichen Features, wie z. B. neue oder erweiterte Properties für die verschiedenen GUI-Komponenten. Um diese Features zu erkennen, wurde in der Javadoc die Annotation @since verwendet. Alle Methoden und Klassen, die zu JavaFX 8 neu hinzugekommen sind, sind hierdurch wie folgt anmontiert: @since JavaFX 8.0

JavaFX: Integration der neuen Java-8-Sprachfeatures und APIs

Bei der Nutzung von JavaFX mit Java 8 merkt man schnell, dass JavaFX bereits von Anfang an für die Nutzung von Lambdas konzipiert wurde. So sind beispielsweise alle Event Handler als functional interfaces aufgebaut. Auch an vielen anderen Stellen wie z. B. bei der Definition von Custom Cells für Listen oder Tabellen wird komplett auf functional interfaces und die Nutzung von Lambdas gesetzt. Listing 1 zeigt, wie ein speziell entwickelter Zellentyp für eine ListView gesetzt und zusätzlich ein event handler registriert wird. Hierbei wird in zwei verschiedenen Varianten die Nutzung mit und ohne Lambdas gezeigt. Beim Betrachten des Beispiels sollte schnell klar werden, dass JavaFX voll und ganz auf die neuen Technologien von Java 8 setzt.

// Mit Lambdas
listView.setCellFactory(c -> new CustomCell());
listView.setOnMouseEntered(e -> System.out.println("Mouse entered"));


// Ohne Lambdas
listView.setCellFactory(new Callback<ListView<Color>, ListCell<Color>>() {
    @Override
    public ListCell<Color> call(ListView<Color> param) {
      return new CustomCell();
    }
});
listView.setOnMouseEntered(new EventHandler() {
    @Override
    public void handle(MouseEvent event) {
      System.out.println("Mouse entered");
    }
});

Neben dem Lambda-Support nutzt JavaFX aber auch noch einige weitere Features von Java. So ist seit Java 8 mit Nashorn eine neue Runtime für JavaScript hinzugefügt worden. Für JavaFX gibt es in Nashorn eine direkte Unterstützung, die es erlaubt, Anwendungen komplett in JavaScript zu schreiben und über das beim JDK mitgelieferte jjs-Tool direkt zu starten. Einen guten Überblick über dieses Feature kann man einem Blog-Post von Gerrit Grunwald entnehmen [1]. Neben dieser Erweiterung wird Nashorn aber auch intern von JavaFX genutzt. Bereits seit einiger Zeit bietet das Toolkit mit FXML eine XML-basierte Sprache zum Erstellen von User Interfaces an. FXML bietet hierbei die Möglichkeit, Controller Logic direkt als JavaScript-Code in die FXML-Dateien einzubetten. Diese Methoden werden mit JavaFX 8 direkt in Nashorn ausgeführt, was neben zusätzlichen Möglichkeiten auch noch einmal einen deutlichen Performanceschub mit sich bringt.
Auch das neue java.time-API von Java 8 findet in JavaFX Verwendung. So ist endlich ein Data Picker als GUI-Komponente enthalten. Dieser musste zuvor über externe Libraries wie etwa JFXtras [2] hinzugefügt werden. Der neue Data Picker (Abb. 1) integriert sich somit perfekt in Java 8 und durch diesen Vorteil ist sicherlich der vorherige Verzicht auf die Komponente in JavaFX verschmerzbar.

Abb. 1: Der neue Data Picker

Aufmacherbild: Colorful smooth twist light lines background von Shutterstock / Urheberrecht: roroto12p

[ header = Seite 2: Neuerungen im Bereich der Collections ]

Neuerungen im Bereich der Collections

JavaFX 8 bringt auch einige neue Erweiterungen für Collections mit. Das ObservableList-Interface, das die java.util.List um die Möglichkeit der Überwachung des Listeninhalts durch die Nutzung von ListChangeListener-Instanzen erweitert, ist bereits fester Bestandteil von JavaFX 2 gewesen. Auf Basis dieses Interface gibt es nun aber einige Erweiterungen wie etwa die TransformationList, die einen Wrapper um eine andere Liste beschreibt. Durch Nutzung der Klasse kann die interne Liste transformiert werden. Implementierungen der TransformationList bietet JavaFX mit der FilteredList und der SortedList, die jeweils automatisch sortierte oder gefilterte Listen zur Verfügung stellen. Alle TransformationList-Implementierungen sind unmodifizierbar, ein Aufruf der add(….)-Methode würde somit zu einer Exception führen. Da diese aber nur als Wrapper um eine andere Liste dienen, kann die ursprüngliche Liste jederzeit problemlos verändert werden. Die Transformation (etwa Filterung oder Sortierung) wird in diesem Fall automatisch ausgeführt. Listing 2 zeigt, wie man mithilfe der FilteredList zum Beispiel auf sehr einfache Weise eine Suche in einer Liste von Strings umsetzten kann.

package com.guigarage.masteringcontrols;
import javafx.application.Application;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.collections.transformation.FilteredList;
import javafx.scene.Scene;
import javafx.scene.control.ListView;
import javafx.scene.control.TextField;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

public class FilteredListDemo extends Application {
  
  @Override
  public void start(Stage primaryStage) throws Exception {
    ObservableList<String> list = FXCollections.observableArrayList("Yoda", "Anakin", "Han", "Luke", "Lando");
    FilteredList<String> filteredList = new FilteredList<String>(list);
    filteredList.setPredicate((e) -> true);
    ListView<String> listView = new ListView<>(filteredList);
    
    listView.setOnMouseEntered((e) -> list.add("DarthVader"));
    
    TextField textField = new TextField();
    textField.textProperty().addListener((e) -> filteredList.setPredicate((v) -> (textField.getText() == null || textField.getText().length() == 0 || v.startsWith(textField.getText()))));
    
    VBox myPane = new VBox(textField, listView);
    Scene myScene = new Scene(myPane);
    primaryStage.setScene(myScene);
    primaryStage.show();
  }
  
  public static void main(String[] args) {
    launch(args);
  }
}

Im Listing wird zuerst eine javafx.collections.ObservableList durch die Util-Klasse FXCollections erstellt. Diese Liste beinhaltet ein paar Strings. Als Nächstes wird eine FilteredList als Wrapper um die Liste erstellt. Diese FilteredList-Instanz wird nun als Datenmodell für eine ListView genutzt. Um zu zeigen, dass die interne Liste jederzeit erweitert werden kann, wird ein Event Handler für Mouse-Events hinzugefügt. Event Handler in JavaFX sind mit den Listener-Interfaces in Swing vergleichbar. Immer wenn die Maus nun über die Liste fährt, wird ein neuer Eintrag und zusätzlich ein Textfeld zur Anwendung hinzugefügt. Dies wird das Suchfeld darstellen, durch das die darzustellenden Ergebnisse der Liste gefiltert werden sollen. Da alle Controls (GUI-Komponenten in JavaFX) ihre Attribute als Properties definieren, kann nun einfach ein Listener an die Text-Property des Textfelds registriert werden. Sobald sich der Text im Textfeld nun ändert, wird dieser Listener aufgerufen. Er wiederum definiert die Filterung der FilteredList abhängig vom Inhalt des Textfelds. Hier kann man auch wieder die Integration von Java 8 sehen, da hier bereits mit dem Predicate-Interface gearbeitet wird, das Bestandteil des neuen java.util.function Packages ist und auch in der Stream API-Verwendung findet. Zuletzt werden die ListView und das TextField noch zu einem Panel hinzugefügt und in der Demoapplikation angezeigt. Startet man die Anwendung, kann man durch Nutzung des Textfelds eine Livesuche im Inhalt der Liste durchführen. Abbildung 2 zeigt beispielhaft, wie das Ergebnis zur Runtime aussieht.

Abb. 2: Livesuche im Inhalt der Liste

[ header = Seite 3: Erweiterung des vorhandenen Concurrency-API ]

Erweiterung des vorhandenen Concurrency-API

Bereits in JavaFX 2 gab es einen sehr guten Support für nebenläufige Anwendungen und Tasks. Im javafx.concurrent Package befinden sich alle Basisklassen, die man benötigt, um Nebenläufigkeit in eine JavaFX-Anwendung effektiv realisieren zu können. So bietet zum Beispiel die abstrakte Task<V>-Klasse eine Erweiterung des java.util.concurrent.FutureTask<V> und ergänzt dessen Möglichkeiten um einige JavaFX Properties, durch die einfach der Status der Task definiert werden kann. In JavaFX ist nun die Möglichkeit des Value-Updates hinzugekommen. Hierdurch lassen sich z. B. schnell Tasks erstellen, die endlos laufen sollen oder Zwischenergebnisse von Tasks zur direkten Weiterverarbeitung veröffentlichen. Listing 3 zeigt, wie man auf dieser Basis einfach eine Endlostask erstellt, die als Timer genutzt werden kann.

package com.guigarage.masteringcontrols;
import javafx.application.Application;
import javafx.concurrent.Task;
import javafx.geometry.Insets;
import javafx.geometry.Pos;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;
import java.util.concurrent.Executors;

public class TaskUpdateDemo extends Application {

  @Override
  public void start(Stage primaryStage) throws Exception {
    Task<String> task = new Task<String>() {
      @Override public String call() {
        long startTime = System.currentTimeMillis();
        while(true) {
          updateValue("millis since start: " + (System.currentTimeMillis() - startTime));
          try {
            Thread.sleep(1);
          } catch (InterruptedException e) {}
        }
      }
    };
    Button button = new Button("Start");
    button.setOnAction((e) -> Executors.newSingleThreadExecutor().execute(task));
    Label valueLabel = new Label();
    valueLabel.textProperty().bind(task.valueProperty());
    VBox box = new VBox(valueLabel, button);
    Scene myScene = new Scene(box);
    primaryStage.setScene(myScene);
    primaryStage.show();
  }
  
  public static void main(String[] args) {
    launch(args);
  }
}

Die im Listing gezeigte Task läuft endlos und veröffentlicht nach jeder Millisekunde ihre Laufzeit. Da das Value als Property von der Task-Klasse zur Verfügung gestellt wird, kann man es einfach an ein Label binden und in diesem darstellen. Da die Task ein Future ist, kann sie wie bereits von Java bekannt über einen Executor gestartet werden. Führt man das Programm aus, so wird die Laufzeit der Task im Label hochgezählt, sobald der Startbutton betätigt wurde.
Als neue Klasse im javafx.concurrent Package ist der ScheduledService hinzugekommen. Mit Hilfe dieser Klasse können periodische Tasks, und zwar über Parameter definiert werden, in welchem Zyklus eine Task wiederholt werden soll oder wie sich das Ganze z. B. in einem Fehlerfall verhalten soll. Listing 4 zeigt anhand eines Beispiels, wie durch Nutzung der Klasse Tasks zyklisch durchgeführt werden können. Die hier definierte Task wird eine Stunde lang im 5-Minuten-Rhythmus durchgeführt.

ScheduledService<Void> service = new ScheduledService() {
  @Override
  protected Task<Void> createTask() {
    return new Task<Void>() {
      @Override
      protected Void call() throws Exception {
        updateDataFromServer();
        return null;
      }
    };
  }
};
service.setRestartOnFailure(true);
service.setPeriod(Duration.minutes(5));
service.setMaximumFailureCount(10);
service.setMaximumCumulativePeriod(Duration.hours(1));

[ header = Seite 4: Neues Theme mit JavaFX ]

Neues Theme mit JavaFX

Das wahrscheinlich Erste, was man sehen wird, wenn man eine Anwendung mit JavaFX 8 erstellt, ist das neue Default Theme. In JavaFX 2 wurde das interne „Caspian“ Theme zur Darstellung aller Controls genutzt. Mit JavaFX 8 wurde mit „Modena“ ein neues Theme hinzugefügt und direkt als Default erklärt. Modena ist deutlich moderner als Caspian und bietet auch einen tiefergehenden Support. Abbildung 3 zeigt eine Beispielanwendung sowohl unter Caspian als auch unter Modena zum Vergleich.

Abb. 3: Modena und Caspian im Vergleich

Wie man in der Abbildung sehen kann, erscheint Modena alles in allem deutlich moderner als die alte Darstellung mit dem Caspian Theme. Beide sind allerdings noch als Cross-Platform Themes ausgelegt. JavaFX bietet auch in der Version 8 noch keine nativen Themes. Allerdings kann man mit JavaFX 8 eigene erstellen. So gibt es mit AquaFX [3] bereits ein Theme, das die Darstellung der Standardkomponenten angelegt an Mac OS Aqua ermöglicht. Ein Theme in JavaFX ist hierbei immer durch eine CSS-Datei realisiert. Allerdings kann man in dieser CSS-Datei Skin-Klassen für Controls hinterlegen. Dies kann für Änderungen genutzt werden, die nicht rein durch CSS realisiert werden können. In diesem Fall kann man das Skin eines Controls programmatisch in Java beeinflussen oder komplett neu gestalten. Durch die Möglichkeit, eigene CSS-Properties in JavaFX 8 zu realisieren, kann man somit eigene Controls flexibel entwickeln oder Erweiterungen für vorhandene Komponenten anbieten. Listing 5 zeigt, wie man zwischen Themes wechseln kann. Hierbei wird das Caspian Theme gesetzt, das noch immer Bestandteil von JavaFX ist.

public class MyApplication extends Application {
  
  public void start(Stage stage) {
    ...
    setUserAgentStylesheet(STYLESHEET_CASPIAN);
    ...
  }
}

Die CSS-Unterstützung von JavaFX erlaubt es übrigens auch, dass für Control-Typen unterschiedliche Styles definiert werden. Diese können dank CSS abhängig von ihrem jeweiligen Kontext innerhalb einer View gesetzt werden. So wird in Modena eine CheckBox in einer Tabellenzelle z. B. anders dargestellt als eine CheckBox, die direkt in der View in einem Panel genutzt wird.

[ header = Seite 5: Weitere Neuerungen im Bereich der Controls ]

Weitere Neuerungen im Bereich der Controls

Neben den bereits erwähnten Data Picker und Modena als neuen Themes, gibt es noch einige zusätzliche Erweiterungen für die Gestaltung von Oberflächen. So bietet JavaFX nun beispielsweise den RichText an, mit dem sich ein Textfluss erstellen lässt, in dem verschiedene Font, Styles etc. genutzt werden. Auch ist es durch RichText möglich, Grafiken oder sogar beliebige JavaFX Nodes in einem Text einzubetten. Intern werden in JavaFX hierbei verschiedene Nodes aneinandergereiht, wobei jeder Textbaustein im Allgemeinen als Label umgesetzt wird. Jedes Label innerhalb des RichText kann nun eigene Properties für Font, Füllfarbe etc. besitzen. Theoretisch kann man sich das Ganze als eine Art FlowLayout vorstellen.
Eine weitere Neuerung bietet der UnifiedStage-Style, der es ermöglicht, eine Stage so darzustellen, dass deren Toolbar in den Head des Windows integriert wird. Hierdurch lassen sich z. B. unter Mac OS Anwendungen erstellen, dessen Darstellung deutlich näher an nativen Anwendungen angelegt ist als zuvor.
Neben der TableView und der TreeView gibt es in JavaFX nun auch die TreeTableView als Standardkomponente. Dieses Control erlaubt es, eine Baumhierarchie innerhalb einer Tabelle darzustellen. Hierdurch ist es sehr einfach möglich, Verzeichnisstrukturen innerhalb einer Tabelle darzustellen und diese mit zusätzlichen Attributen zu versehen. Diese Komponente wird in Betriebssystemen daher auch oft zur Darstellung im Explorer genutzt.

JavaFX bietet Print-Support

JavaFX bietet nun auch ein eigenes Print-API an, mit dem beliebige Inhalte gedruckt werden können. Entwickler, die bereits mit dem Print-API von Swing zu tun hatten, werden sich hier schnell heimisch fühlen. Als einfaches Anwendungsbeispiel des API beinhaltet Listing 6 eine Methode zum Drucken einer beliebigen GUI-Komponente. Hierbei wird ein javafx.print.PrinterJob erstellt, der auf einem javafx.print.Printer die Komponente im definierten javafx.print.PageLayout ausdruckt. Besondere Komponenten wie die WebView bieten direkte Unterstützung des Print-API, sodass durch Aufruf der WebView.getEngine().print(PrinterJob job)-Methode direkt die in der WebView angezeigte HTML-Seite gedruckt werden kann.

public void print(final Node node) {
  Printer printer = Printer.getDefaultPrinter();
  PageLayout pageLayout = printer.createPageLayout(Paper.A4, PageOrientation.PORTRAIT, Printer.MarginType.DEFAULT);
  double scaleX = pageLayout.getPrintableWidth() / node.getBoundsInParent().getWidth();
  double scaleY = pageLayout.getPrintableHeight() / node.getBoundsInParent().getHeight();
  node.getTransforms().add(new Scale(scaleX, scaleY));
  
  PrinterJob job = PrinterJob.createPrinterJob();
  if (job != null) {
    boolean success = job.printPage(node);
    if (success) {
      job.endJob();
    }
  }
}

[ header = Seite 6: JavaFX goes 3-D ]

JavaFX goes 3-D

Eine weitere besondere Neuerung in JavaFX 8 ist die 3-D-Unterstützung. Hierbei bietet JavaFX neben den Controls und Shapes den neuen Node-Typ Shape3D. Durch diese Klasse können 3-D-Komponenten zu einem JavaFX Scene Graph hinzugefügt werden und problemlos mit 2-D-Komponenten kombiniert werden. Da sowohl die 2-D- als auch die 3-D-Komponenten von der Basisklasse Node erben, ist eine Nutzung der 3-D-Features in JavaFX nicht deutlich schwerer, als eine reine 2-D-Anwendung zu entwickeln. JavaFX bietet von Haus aus verschiedene 3-D-Objekte wie eine Box oder einen Zylinder an. Zusätzlich unterstützt das API Lichtquellen und Texturen und Oberflächenmaterialien. Auch das Picking von 3-D-Objekten ist in JavaFX integriert. Theoretisch kann jedes beliebige 3-D-Objekt mit JavaFX dargestellt werden. So lässt sich im OpenJFX Repository zum Beispiel ein 3-D-Viewer finden, der verschiedene 3-D-Formate wie Wavefront OBJ oder 3D Studio Max darstellen und direkt nach Java exportieren kann. Abbildung 4 zeigt einen Screenshot des Viewers.

Abb. 4: Viewer

Hilfsmittel für eine Migration von Swing zu JavaFX

Für Entwickler, die eine vorhandene Swing-Anwendung nach JavaFX migrieren wollen, ist vor allem der SwingNode interessant. Diese Komponente kann genutzt werden, um Swing-Inhalte in eine JavaFX-Umgebung zu integrieren. So können bei einer Migration selbsterstellte Swing-Komponenten, die noch nicht in JavaFX vorliegen, in die neue JavaFX-Anwendung integriert und schrittweise ersetzt werden. Parallel zu dieser Komponente gibt es bereits seit JavaFX 2 das JFXPanel, eine Swing-Komponente, in die JavaFX Views integriert werden können.
Bisher musste man bei der Benutzung von Swing und JavaFX innerhalb einer Anwendung darauf achten, dass beide UI-Toolkits ihren eigenen Thread zum Rendern und Abarbeiten von Events benötigen. In Swing ist dies der „EDT“ und in JavaFX der „JavaFX Application Thread“. Listing 7 zeigt, wie man beispielsweise ein JavaFX Control über einen AktionListener einer Swing-Komponente aktualisieren kann. Hierbei ist darauf zu achten, dass durch den Aufruf Platform.runLater(….) der übergebene Lambda-Ausdruck im „JavaFX Application Thread“ ausgeführt wird. Im Gegenzug gibt es für Swing die Methode SwingUtilies.invokeLater(…).

Label labelFX = new Label("JavaFX Label");

JButton buttonSwing = new JButton("Swing Button");

button.addActionListener(event -> {
    Platform.runLater(() -> labelFX.setText("Swing aktualisiert JavaFX"));
});

JavaFX bietet nun einen experimentellen Support, um den EDT und „JavaFX Application Thread“ zu vereinen. Hierzu muss beim Start der Anwendung nur -Djavafx.embed.singleThread=true gesetzt werden und schon kann man das vorherige Beispiel, wie in Listing 8 gezeigt, umsetzten. Da der Support aktuell noch experimentell ist, kann es hier natürlich zu Problemen kommen und Entwickler sollten vor allem im Produktivbetrieb genauestens überprüfen, ob die erstellten Konstellationen problemlos lauffähig sind.

Label labelFX = new Label("JavaFX Label");

JButton buttonSwing = new JButton("Swing Button");

button.addActionListener(() -> labelFX.setText("Swing aktualisiert JavaFX"));

[ header = Seite 7: Weitere Neuerungen & Fazit ]

Weitere Neuerungen

Neben den hier genannten Neuerungen ist JavaFX mit dem Erscheinen von Java 8 komplett Open Source. Lediglich ein paar Fonts und Media-Codecs konnten aus Lizenzgründen nicht offen gelegt werden. Alle Sourcen können im OpenJFX [4] gefunden werden. Dazu beinhaltet das JDK auch die javafx-src.zip-Datei, in der alle Sourcen von JavaFX beinhaltet sind. Aktuelle Versionen von IDEs wie etwa IntelliJ integrieren diese Sourcen auch bereits automatisch, sodass von Beginn an ein komfortables Arbeiten möglich ist.
Mit Java 8 bietet Oracle Embedded-Support an, sodass Java und dadurch auch JavaFX auf Plattformen wie dem Raspberry Pi lauffähig ist. Dieser liefert seit Neuestem sogar Java standardmäßig im OS-Image mit aus. Hierdurch lassen sich im Embedded-Bereich sehr einfach moderne Oberflächen erstellen. Beispiele kann man hierzu im Netz bereits einige finden [5], [6], [7].
Zusätzlich bietet Oracle für JavaFX auch bereits einige Tools an. Mit am interessantesten ist hier sicherlich der Scene Builder. Dieses Tool bietet einen WYSIWYG-Editor, durch den FXML-basierte Views einfach zusammengeklickt und mithilfe von CSS sogar direkt gestylt werden können. Das Tool liegt aktuell in der Version 2 vor und bietet volle Unterstützung für JavaFX 8. Abbildung 5 zeigt den Scene Builder mit einem einfachen Dialog in Bearbeitung.

Abb. 5: Scene Builder

Fazit

JavaFX integriert sich mit der neuen Version perfekt in Java 8 und nutzt bereits heute einen Großteil der neuen Sprachfeatures und APIs. Darüber hinaus wurden die APIs seit der Version 2 konsequent weiterentwickelt und sinnvoll um neue Punkte ergänzt. Bestandteile, wie etwa der Data Picker oder die Möglichkeit der Erstellung von eigenen Themes, die in JavaFX 2 von vielen Entwicklern noch vermisst wurden, sind neu hinzugekommen und lassen JavaFX als eine modernes und in sich abgeschlossenes UI-Toolkit erscheinen. Dazu sind Neuerungen wie etwa der 3-D-Support integriert worden. Hierdurch kann sich JavaFX deutlich von anderen UI-Toolkits abheben und bietet flexible Möglichkeiten und Komponenten für die verschiedensten Anwendungstypen. Mit der Version 8 ist JavaFX auf jeden Fall bereit für den produktiven Einsatz und wird sicherlich in naher Zukunft Swing mehr und mehr ablösen.

Geschrieben von
Hendrik Ebbers
Hendrik Ebbers
Hendrik Ebbers (@hendrikEbbers) ist Java-Entwickler bei der Canoo Engineering AG. Sein Hauptinteresse liegt hierbei in den Bereichen JavaFX, User Interfaces und Middleware. Hendrik leitet die JUG Dortmund. Auf seiner Webseite www.guigarage.com bloggt er regelmäßig über Architekturansätze im Bereich JavaFX und zu seinen verschiedenen Open-Source-Projekten wie Dolphin Platform oder DataFX. Sein Buch "Mastering JavaFX 8 Controls" ist 2014 bei Oracle Press erschienen. Hendrik ist JavaOne Rockstar, Java Champion und JCP Expert Group Member.
Kommentare

Hinterlasse einen Kommentar

1 Kommentar auf "JavaFX 8 – Was ist neu?"

avatar
400
  Subscribe  
Benachrichtige mich zu:
Henrik
Gast

Hallo Hendrik,

ich hätte mal eine ganz einfache Frage: Was muß ich tun um, bzw. wie kann ich eine „Hallo Welt“ Web-anwendung schreiben? Also etwas, was ich per URI im Browser aufrufe und dies dann auch direkt im Browser ausgeführt wird, also nicht in einem seperatem Fenster und nicht auf einer neuen Seite, sondern innerhalb einer ganz nomalen Web-Seite. Ok, ich weiß natürlich nicht, ob das zu viele Wünsche auf einmal sind…

Grüße
Henrik