JavaFX 8 - Anton Epple - ebook

JavaFX 8 ebook

Anton Epple

0,0

Opis

Dieses Buch bietet Ihnen einen schnellen Einstieg und umfassenden Überblick über die gesamte JavaFX-API. Schritt für Schritt zeigt es, wie Sie eine erste Anwendung bauen, wie Sie das eigene Datenmodell in der Oberfläche darstellen und editierbar machen und wie Sie die Anwendung mit JavaFX-Features anreichern, um ein modernes und ansprechendes User Interface zu erhalten. Dabei lernen Sie u.a., folgende Möglichkeiten von JavaFX einzusetzen: • Controls nutzen und anpassen • Formulare layouten und eigene Layouts erstellen • Charts/Diagramme erzeugen • Animationen erstellen • Audio und Video einbinden • Anwendungen mit CSS stylen • Nebenläufigkeit nutzen Anhand eines durchgängigen Beispiels können Sie die besprochenen Inhalte praktisch nachvollziehen und vertiefen. Darüber hinaus können Sie das Buch bei der späteren Projektarbeit zum Nachschlagen einsetzen. Das Buch richtet sich gleichermaßen an Einsteiger und Umsteiger in JavaFX: • Entwickler mit Swing-Erfahrung lernen, welche Änderungen das Arbeiten mit einem SceneGraph mit sich bringt und wie sie Anwendungen schrittweise mit JavaFX anreichern und schließlich portieren können. • Java-Entwickler, die erst in die GUI-Entwicklung einsteigen, lernen von Grund auf, wie man moderne Benutzeroberflächen entwickelt und dabei JavaFX einsetzt.

Ebooka przeczytasz w aplikacjach Legimi na:

Androidzie
iOS
czytnikach certyfikowanych
przez Legimi
Windows
10
Windows
Phone

Liczba stron: 287

Odsłuch ebooka (TTS) dostepny w abonamencie „ebooki+audiobooki bez limitu” w aplikacjach Legimi na:

Androidzie
iOS



Anton Epple hat mehr als fünfzehn Jahre Erfahrung in der Leitung von Java-Projekten und veröffentlichte zahlreiche Artikel über das Thema. Er ist weltweit als Berater für eine Vielzahl von Unternehmen tätig, angefangen bei Start-ups bis hin zu Fortune-500-Unternehmen. In seiner Freizeit organisiert er Events für die Java-Community. Anton ist ein Mitglied des NetBeans Dream Team, 2013 wurde er zum Java Champion und JavaOne Rockstar ernannt, und 2014 wurde ihm für seine Arbeit am DukeScript-Framework der Duke’s Choice Award verliehen.

Zu diesem Buch – sowie zu vielen weiteren dpunkt.büchern – können Sie auch das entsprechende E-Book im PDF-Format herunterladen. Werden Sie dazu einfach Mitglied bei dpunkt.plus+:

www.dpunkt.de/plus

JavaFX 8

Grundlagen und fortgeschrittene Techniken

Anton Epple

Anton [email protected]

Lektorat: René SchönfeldtCopy-Editing: Ursula Zimpfer, HerrenbergHerstellung: Frank HeidtUmschlaggestaltung: Helmut Kraus, www.exclam.deDruck und Bindung: M.P. Media-Print Informationstechnologie GmbH, 33100 Paderborn

Bibliografische Information der Deutschen NationalbibliothekDie Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie;detaillierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar.

ISBN:Buch    978-3-86490-169-0PDF    978-3-86491-649-6ePub    978-3-86491-650-2

1. Auflage 2015Copyright © 2015 dpunkt.verlag GmbHWieblinger Weg 1769123 Heidelberg

Die vorliegende Publikation ist urheberrechtlich geschützt. Alle Rechte vorbehalten. Die Verwendung der Texte und Abbildungen, auch auszugsweise, ist ohne die schriftliche Zustimmung des Verlags urheberrechtswidrig und daher strafbar. Dies gilt insbesondere für die Vervielfältigung, Übersetzung oder die Verwendung in elektronischen Systemen.Es wird darauf hingewiesen, dass die im Buch verwendeten Soft- und Hardware-Bezeichnungen sowie Markennamen und Produktbezeichnungen der jeweiligen Firmen im Allgemeinen warenzeichen-, marken- oder patentrechtlichem Schutz unterliegen.Alle Angaben und Programme in diesem Buch wurden mit größter Sorgfalt kontrolliert. Weder Autor noch Verlag können jedoch für Schäden haftbar gemacht werden, die in Zusammenhang mit der Verwendung dieses Buches stehen.

5 4 3 2 1 0

Inhaltsverzeichnis

Vorwort

1        Workshop: Eine erste Anwendung erstellen

1.1     Ein JavaFX-Projekt mit der Entwicklungsumgebung anlegen

1.1.1      Wie erstelle ich ein JavaFX-Projekt in NetBeans?

1.1.2      Wie erstelle ich ein JavaFX-Projekt mit IDEA?

1.1.3      Wie erstelle ich ein JavaFX-Projekt mit Eclipse?

1.1.4      Ein JavaFX-Projekt mit Maven erstellen

1.1.5      Hallo Welt!

2        Wie ist eine JavaFX-Anwendung aufgebaut?

2.1     Anfang und Ende – die Application

2.1.1      Lebenszyklus einer JavaFX-Anwendung

2.1.2      Aufrufparameter auslesen

2.2     Vorhang auf – die Stage

2.2.1      Dialoge anzeigen

2.2.2      Darstellung der Stage verändern

2.2.3      Die Scene – Was wird gespielt?

2.2.4      Nodes – die Darsteller

2.3     Wie werden Layouts verwendet?

2.4     Workshop: Einen Twitter-Client erstellen

2.4.1      Vorbereitung

2.4.2      Die Anwendung erzeugen

2.4.3      Mit Twitter4j auf die Timeline zugreifen

3        Properties und Bindings

3.1     Beans und Properties

3.1.1      Klassische JavaBean-Properties

3.1.2      Die neuen JavaFX-Properties

3.1.3      Was sind die wichtigsten Klassen und Interfaces?

3.1.4      Wie legt man Properties an?

3.1.5      Wie findet man die Bean zu einer Property?

3.1.6      Wie werden Properties schreibgeschützt?

3.2     Wie verwendet man Bindings?

3.2.1      High-Level- und Low-Level-APIs

3.2.2      Wie können Bindings logisch verknüpft werden?

3.2.3      Was für Berechnungen sind mit numerischen Bindings möglich?

3.2.4      Wie verwendet man StringProperties in Bindings?

3.2.5      Was passiert, wenn wir den Wert einer gebundenen Property setzen?

3.2.6      Bidirektionale Bindings

3.2.7      Wenn, dann und ansonsten – noch mehr Bindings-Logik

3.3     Mit Listenern auf Änderungen reagieren

3.3.1      InvalidationListener

3.3.2      ChangeListener

3.3.3      Welchen Listener soll ich verwenden?

3.4     JavaFX Collections

3.4.1      Welche sind die wichtigsten Klassen und Interfaces?

3.4.2      Wie erzeuge ich eine JavaFX Collection?

3.4.3      Wie reagiere ich auf Änderungen?

3.4.4      Wie verwende ich Bindings mit ObservableList?

3.4.5      Wie observiere ich einen bestimmten Wert einer Collection?

3.4.6      Wie erzeuge ich eine Lazy ObservableList?

3.5     Properties und Performance

3.6     Grenzen der Verwendung von Properties

4        Welche Bedienelemente gibt es?

4.1     Welche Controls stehen zur Verfügung?

4.2     Wie werden Controls verwendet?

4.2.1      Wie werden Labels verwendet?

4.2.2      Tooltip

4.2.3      Buttons

4.2.4      Texteingabe mit TextField, PasswordField, TextArea und HTMLEditor

4.2.5      Numerische Werte mit dem Slider eingeben

4.2.6      Menüs und Kontextmenüs erstellen

4.2.7      ListView

4.2.8      TableView

4.2.9      TreeView und TreeTableView

4.2.10    Auswahlfelder

4.3     Controls fürs Layout verwenden

4.3.1      Accordion-Control und TitledPane verwenden

4.3.2      Mehrere Seiten mit der TabPane verwalten

4.3.3      Blättern mit Touchgesten und dem Pagination-Control

4.3.4      SplitPane

4.4     Workshop: Eine ListView für die Twitter-App

5        Ein Layout erstellen

5.1     Die eingebauten Layouts verwenden

5.1.1      VBox und HBox

5.2     Die BorderPane verwenden

5.3     Layouts mit der AnchorPane erstellen

5.4     Die FlowPane verwenden

5.5     Layout mit der StackPane

5.6     Layout mit der TilePane

5.7     Layout mit der GridPane

5.7.1      Wie füge ich Nodes hinzu?

5.7.2      Wie passt man Höhe und Breite der Columns und Rows an?

5.7.3      Wie werden einzelne Elemente ausgerichtet?

5.8     Unmanaged Nodes

5.9     Eigene Layoutcontainer erstellen

5.10   Workshop: Ein bestimmtes Layout umsetzen

6        Formulare mit FXML erstellen

6.1     Wozu FXML?

6.2     Beispielprojekt

6.3     Layouts per Drag-and-Drop mit dem SceneBuilder erstellen

6.3.1      Wie wird der SceneBuilder installiert?

6.3.2      Wie integriere ich den SceneBuilder mit NetBeans?

6.3.3      Wie verwende ich den SceneBuilder mit e(fx)clipse?

6.3.4      Wie konfiguriere ich IntelliJ IDEA?

6.3.5      Wie erstelle ich ein Formular?

6.4     Das FXML-Format verstehen

6.5     Daten an den Controller anbinden

6.5.1      Member-Variablen annotieren

6.5.2      Sonderfälle ResourceBundle und URL

6.5.3      Methoden annotieren

6.5.4      Sonderfall initialize-Methode

6.6     FXML-Dateien laden

6.7     FXMLLoader und Internationalisierung

6.8     Eigene Nodes verwenden

6.9     Workshop: Einen Taschenrechner erstellen

6.10   Fazit

7        Den Look mit CSS gestalten

7.1     Beispielanwendung

7.2     CSS Basics

7.2.1      Selektoren

7.2.2      Eigenschaften und Deklarationen

7.2.3      Eigenschaftsvererbung

7.2.4      Zusammenfassende Eigenschaften

7.2.5      Namenskonventionen

7.2.6      Die wichtigsten stylebaren Eigenschaften

7.2.7      Stylebare Eigenschaften eines Nodes

7.2.8      Shapes

7.2.9      Region und Controls

7.2.10    Verwendung im Beispiel

7.2.11    Besonderheiten

7.2.12    UserAgent-Stylesheet

7.2.13    Stylesheet einer Scene

7.2.14    Stylesheet eines Parent

7.2.15    Eigenschaften über die Java-API setzen

7.2.16    Inline-Styles

7.2.17    CSS-API

7.3     Workshop: Eine Anwendung stylen

7.3.1      Wie registriere ich das Stylesheet?

7.3.2      Wie definiere ich Variablen?

7.3.3      Wie style ich den Hintergrund?

7.3.4      Wie style ich den Home-Button?

7.3.5      Wie reagiere ich im Style auf Buttonklicks?

7.3.6      Wie style ich den StatusView?

7.4     Workshop: Eine Anwendung im SceneBuilder stylen

7.4.1      Wie kann ich im SceneBuilder eine CSS-Datei registrieren?

7.4.2      Wie erzeuge ich einen LCD-Screen-Effekt?

7.4.3      Wie kann ich in CSS einen Font laden?

7.4.4      Wie erzeuge ich Pseudo-3D-Buttons?

7.4.5      Wie weise ich einem Node eine Id zu?

7.4.6      Wie trage ich im SceneBuilder eine Styleklasse ein?

7.4.7      Stylecheck mit dem CSS-Analyzer

7.5     Fazit

8        Charts erstellen

8.1     Ein Diagramm anzeigen

8.2     Aufbau der API

8.2.1      Achsen

8.2.2      Daten

8.3     Welche Diagrammtypen gibt es?

8.3.1      LineChart und AreaChart

8.3.2      PieChart

8.3.3      BarChart

8.3.4      ScatterChart

8.3.5      BubbleChart

8.4     Dynamische Charts

9        Nebenläufigkeit und Fortschrittsanzeige

9.1     JavaFX und die gefühlte Performance

9.2     Die Klassen der javafx.concurrent-API

9.2.1      Worker

9.2.2      Task

9.2.3      Service

9.2.4      ScheduledService

9.3     Fortschritt anzeigen

9.3.1      ProgressBar

9.3.2      ProgressIndicator

9.3.3      Fortschrittskomponenten anpassen

9.4     Workshop: Automatische Updates für den Twitter-Client

9.4.1      Wie erzeuge ich einen Refresh Task?

9.4.2      Wie kann der Task wiederholt aufgerufen werden?

9.4.3      Wie rufe ich den Service periodisch auf?

9.4.4      Wie aktualisiere ich das UI?

9.5     Fazit

10       Grafische Anwendungen mit Shapes gestalten

10.1     Den SceneGraph verstehen – Unterschiede zu Swing

10.2     Nodes für Grundformen

10.2.1     Rectangle

10.2.2     Circle

10.2.3     Ellipse

10.2.4     Schnittmengen bilden

10.2.5     Line

10.2.6     Eigenschaften des Linienstrichs verändern

10.2.7     Polyline und Polygon

10.2.8     Arc, CubicCurve und QuadCurve

10.2.9     Text

10.3     Pfade und SVG

10.4     Grafiken mit Effekten versehen

10.4.1     Wie erzeuge ich einen Schlagschatten?

10.4.2     Wie verwende ich den InnerShadow?

10.4.3     Wie verwende ich Reflection?

10.4.4     Der Blend-Effekt

10.4.5     Der Bloom-Effekt

10.4.6     Wie kann ich Effekte verknüpfen?

11        Animationen erstellen

11.1     Vorgefertigte Transitionen verwenden

11.1.1     Eine Transition steuern

11.1.2     Start- und Endwert setzen

11.1.3     Eine Transition in Schleifen abspielen

11.1.4     PathTransition

11.2     Animationen in parallelen und sequenziellen Transitionen organisieren

11.3     Timeline und KeyFrames

11.3.1     Besonderheit des ersten KeyFrame

11.3.2     Interpolierbare Typen und das Interface Interpolatable

11.4     Interpolatoren

11.4.1     Vordefinierte Interpolatoren

11.4.2     Einen eigenen Interpolator erstellen

11.5     Eigene Transitionen erstellen

12        Auf systemnahen Input reagieren

12.1     Welche sind die wichtigsten Klassen?

12.1.1     Target

12.1.2     Source

12.1.3     EventType

12.1.4     EventHandler

12.2     Wie werden Events verteilt?

12.2.1     Event Target Selection

12.2.2     Event Route Construction

12.2.3     Event Capturing Phase

12.2.4     Event Bubbling Phase

12.3     Wie reagiert man auf Events?

12.3.1     EventHandler Properties

12.3.2     EventHandler- und EventFilter-Registrierung

12.3.3     EventDispatcher

13        Die WebView nutzen

13.1     Wie zeige ich eine Webseite an?

13.2     Wie kann ich JavaScript ausführen?

13.2.1     Geht das auch einfacher?

13.3     Wie funktionieren Callbacks von JavaScript nach Java?

13.4     Workshop: Twitter-Authentifizierung einbauen

13.4.1     Erweiterungsmöglichkeiten

14        Audio und Video einbinden

14.1     Wie kann ich Audio abspielen?

14.1.1     Wie überwache ich den Zustand des Players?

14.1.2     Wie kontrolliere ich den Sound?

14.1.3     Welche Audioformate werden unterstützt?

14.2     Wie kann ich eine Videodatei abspielen?

14.2.1     Welche Videoformate werden unterstützt?

14.3     Wie kann ich damit auch YouTube-Videos abspielen?

15        Canvas-API

15.1     Retained Mode vs. Immediate Mode

15.2     Elemente anzeigen

15.2.1     Einfache Formen

15.2.2     Komplexe Formen (Path)

15.2.3     Den Stil ändern

15.2.4     Bilder

15.2.5     Text

15.2.6     Einzelne Pixel

15.3     Fortgeschrittene Techniken

15.3.1     Transformationen

15.3.2     State Stack

15.3.3     Global Alpha und Blend Mode

15.3.4     Effekte

15.4     Unterschiede zum HTML Canvas

15.4.1     Methoden zur Anzeige von Shapes

15.4.2     Typen der Properties

15.4.3     Hitareas

15.4.4     Effekte

15.5     Aufgabe

15.5.1     Erweiterungsmöglichkeiten

16        JavaFX und Internationalisierung

16.1     Wie verwendet man Locale und ResourceBundles?

16.1.1     Wie verwendet man ResourceBundles mit FXML?

Index

Vorwort

JavaFX ist Oracles Framework für plattformübergreifende Rich Internet Applications. Nachdem Swing inzwischen sehr in die Jahre gekommen ist, wurde mit JavaFX der Versuch unternommen, moderne Prinzipien zur Erstellung von Benutzeroberflächen umzusetzen. Insbesondere setzt JavaFX auf SceneGraph, deklaratives Layoutformat, Properties und Bindings für die einfache Anbindung des UI an das Datenmodell und auf die Verwendung von CSS für das Stylen der Anwendung.

In diesem Buch führe ich diese Konzepte ein und gebe eine Übersicht der verfügbaren APIs. Besonders umfassend gehe ich dabei auf die verfügbaren Controls ein und setze die Inhalte in zahlreichen Beispielen praktisch um.

Für wen ist dieses Buch?

Dieses Buch ist für Entwickler gedacht, die einen Überblick über die Verwendbarkeit von JavaFX in der Praxis suchen. Grundkenntnisse in der Entwicklung von Java-Anwendungen werden vorausgesetzt. Vorkenntnisse in der Erstellung grafischer Benutzeroberflächen sind hilfreich, aber nicht unbedingt erforderlich.

Ziel des Buches ist es, interessierten Entwicklern eine Entscheidungshilfe bei der Evaluierung von JavaFX an die Hand zu geben und ihnen – sollten sie sich für JavaFX entscheiden – gleich die Grundkenntnisse zu vermitteln, die sie für den Start mit dieser modernen Benutzeroberflächentechnologie in der Praxis benötigen. Dazu war es mir wichtig, neben Erklärungen zu den Programmierschnittstellen auch viele praktische Übungen anzubieten. Das Ausprobieren ist immer noch der schnellste Weg, um sich eine Meinung über eine Technologie zu bilden.

Ich habe diese Buch auch als Begleitung zu meinem JavaFX-Kurs konzipiert. Es ergänzt und komplettiert dessen Inhalte und eignet sich zum Repetieren oder zum Selbststudium. In vielen kleinen Codebeispielen wird die grundlegende Verwendung der Programmierschnittstellen gezeigt, und es gibt Tipps und Tricks für die Lösung von komplexeren Problemen.

Wie ist das Buch zu lesen?

Sie müssen das Buch nicht unbedingt in der vorgegebenen Kapitelreihenfolge durcharbeiten. Sobald Sie die Grundlagen aus Kapitel 1 und 2 verstanden haben, können Sie auch gleich zu einem anderen Thema springen, das Sie besonders interessiert. Die einzelnen Kapitel sind in der Regel in sich abgeschlossen und auch für sich allein verständlich. Das Buch soll für Sie später außerdem nützlich sein, wenn Sie etwa ein spezielles Thema nachschlagen möchten, um etwa zu sehen, wie man eine Animation steuert oder wie man ein bestimmtes Control verwendet.

Die Codebeispiele online

Die Codebeispiele zu den einzelnen Kapiteln finden Sie auf Github unter https://github.com/eppleton/javafxbuch. Dort gibt es auch Hinweise, wie Sie die einzelnen Beispiele herunterladen und ausführen können. Damit die Beispiele mit allen Entwicklungsumgebungen verwendet werden können, habe ich sie als Maven-Projekte erstellt.

Danksagung

Als ich mich auf dieses Buchprojekt eingelassen habe, war mir klar, dass eine Menge Arbeit auf mich zukommt. Deshalb war ich besonders dankbar, als Michael Heinrichs mir anbot, zwei Kapitel über Animationen und die Canvas API beizutragen. Michael war selbst als Mitglied des JavaFX-Teams bei Oracle für die Bindings und Animationen zuständig. Ich bedanke mich herzlich für seinen Beitrag.

Ich möchte mich auch besonders beim dpunkt.verlag für die Idee zu diesem Buch und für die Unterstützung bei Konzeption und Korrektur sowie die Ermutigung während des Schreibens bedanken. Insbesondere bedanke ich mich bei René Schönfeldt für die Geduld mit dem chronisch überlasteten Autor. Mein ganz besonderer Dank gilt Babs, die abends zu Hause unter meiner zusätzlichen Arbeitsbelastung zu leiden hatte und mich trotzdem immer bei diesem Vorhaben unterstützt hat.

1 Workshop: Eine erste Anwendung erstellen

Wir wollen nun zunächst ein Projekt mit dem Namen »Hello World« und der Hauptklasse de.javafxbuch.helloworld.Main erzeugen. Dazu sehen wir uns einmal an, wie ein JavaFX-Projekt in den am weitesten verbreiteten IDEs angelegt wird. Aber auch IntelliJ IDEA und Eclipse bieten gute Unterstützung für die Entwicklung von Anwendungen mit JavaFX.

1.1 Ein JavaFX-Projekt mit der Entwicklungsumgebung anlegen

Falls Sie noch keine Entwicklungsumgebung verwenden, empfehle ich Ihnen, NetBeans zu benutzen, da das Anlegen von Projekten sehr einfach ist und nichts konfiguriert werden muss. Hier ist der Einstieg am leichtesten.

1.1.1 Wie erstelle ich ein JavaFX-Projekt in NetBeans?

Egal welche Distribution von NetBeans 8 Sie herunterladen, JavaFX-Unterstützung ist automatisch mit dabei.

Das Erste, was jeder Softwareentwickler mit einer neuen Technologie macht, ist das unvermeidliche »Hello World!«-Programm. In diesem Kapitel sehen Sie, wie die JavaFX-Variante davon aussieht und wie sie funktioniert.

1. Um ein JavaFX-Projekt anzulegen, aktivieren Sie die Schaltfläche New Project in der Werkzeugleiste:

2. Es öffnet sich ein Dialog. Wählen Sie hier unter Categories den Unterpunkt JavaFX und unter Projects die Option JavaFX Application. Klicken Sie dann auf die Schaltfläche Next.

3. Im nächsten Fenster können Sie einen Projektnamen (Hello World) und ein Package (de.javafxbuch.helloworld) sowie Main als Name der Hauptklasse eingeben. Ein Klick auf Finish legt das Projekt dann an, und Sie sind startbereit.

NetBeans aktiviert die Unterstützung für neue Projekttypen bei der ersten Benutzung. So wird sichergestellt, dass nur die Projekttypen aktiviert sind, die tatsächlich genutzt werden. Das wirkt sich positiv auf Startup-Zeit und Performance der IDE aus. Beim ersten JavaFX-Projekt, das Sie anlegen, sind die verschiedenen Projekttypen daher noch grau dargestellt, und es dauert einige Sekunden, bis NetBeans den JavaFX-Support aktiviert hat.

1.1.2 Wie erstelle ich ein JavaFX-Projekt mit IDEA?

IntelliJ IDEA bietet ab Version 12.1 ebenfalls Unterstützung für die Entwicklung von JavaFX-Anwendungen.

1. Starten Sie über das Menü File → New Project den New Project Wizard.

2. Wählen Sie in der Kategorie Java die JavaFX Application und vergeben Sie Hello World als Projektnamen. Stellen Sie sicher, dass eine geeignete JDK (8.x) ausgewählt ist, und klicken Sie auf finish.

3. Die IDE legt im Package sample einige Beispieldateien an. Löschen Sie die Dateien Controller und sample.fxml.

4. Aktivieren Sie per Rechtsklick das Kontextmenü des Package sample, wählen Sie Rename und geben Sie de.javafxbuch.helloworld als neuen Package-Namen an.

1.1.3 Wie erstelle ich ein JavaFX-Projekt mit Eclipse?

Mit e(fx)clipse gibt auch für Eclipse eine komfortable Unterstützung für das Entwickeln von JavaFX-Anwendungen. e(fx)clipse steht für Eclipse Juno und Kepler zur Verfügung. Unter http://eclipse.org/efxclipse finden Sie die passenden Plug-ins. Es steht dort auch eine vorkonfigurierte Eclipse-Distribution zur Verfügung, die diese Erweiterungen bereits enthält. Ich empfehle Ihnen für den Anfang und der Einfachheit halber, diese Distribution zu verwenden.

Haben Sie e(fx)clipse heruntergeladen und installiert, können Sie ein neues JavaFX-Projekt wie folgt anlegen:

1. Wählen Sie im Menü File → New → Project:

2. Es öffnet sich ein Dialog mit mehreren Projekttypen. Wählen Sie hier JavaFX → JavaFX Project.

3. Im nächsten Dialogfenster können Sie den Namen Hello World für Ihr Projekt vergeben. Betätigen Sie dann die Schaltfläche finish.

4. Nun legen Sie ein neues Package namens de.javafxbuch.helloworld an. Öffnen Sie dazu per Rechtsklick auf Ihr JavaFX-Projekt das Kontextmenü und wählen Sie New → Package.

5. Es öffnet sich ein Dialog. Geben Sie hier den Package-Namen an.

6. Öffnen Sie per Rechtsklick das Kontextmenü des Package und wählen Sie New → Other. Es öffnet sich der Select a Wizard-Dialog.

7. Unter JavaFX → classes finden Sie den Eintrag JavaFX Main Class. Wählen Sie diesen und klicken Sie auf die Schaltfläche Next.

8. Geben Sie im nächsten Formular noch Main als Namen an und Klicken Sie auf finish. Ihre erste Anwendung ist nun startbereit.

1.1.4 Ein JavaFX-Projekt mit Maven erstellen

Je nach IDE wird für das Kompilieren, Testen und Ausliefern des Projektes ein Buildsystem verwendet. Alternativ dazu können alle diese IDEs (Eclipse nach Installation der entsprechenden Plug-ins) auch Maven als Build-System verwenden. Inzwischen gibt es einige Archetypen dafür. Ein Vorteil der Verwendung von Maven als Build-System ist, dass die Projekte sehr portabel sind. Richtig verwendet kann so jeder Entwickler im Team seine bevorzugte IDE verwenden, um gemeinsam ein Projekt zu entwickeln. Besonders komfortabel funktioniert das in NetBeans, wo ein Maven Archetype für JavaFX bereits vorkonfiguriert ist. Sie können aber auch die Kommandozeile verwenden, um ein JavaFX-Projekt mit Maven anzulegen. Vorbedingung ist, dass Sie Maven 3 auf Ihrem Computer installiert und im Pfad verfügbar gemacht haben.1

1. Öffnen Sie ein Terminal und geben Sie den folgenden Befehl ein:

mvn archetype:generate-DarchetypeGroupId=com.zenjava-DarchetypeArtifactId=javafx-basic-archetype-DarchetypeVersion=2.0.1

2. Sie werden aufgefordert, einige Parameter festzulegen. Geben Sie die folgenden Werte ein:

groupid: „de.javafxbuch″artifactid: „hello-world″version: ″1.0-SNAPSHOT”package: ″de.javafxbuch.helloworld”organizationName: ″Meine Firma”

3. Maven verwendet diese Daten, um ein Projekt zu konfigurieren. Sie können dieses anschließend in der IDE Ihrer Wahl öffnen.

4. Löschen Sie im Pfad hello-world/src/java/de/javafxbuch/helloworld die Klasse HelloController.java und den Inhalt des Ordners hello-world/src/resources.

1.1.5 Hallo Welt!

Unabhängig davon, welchen Weg Sie gewählt haben, nun sind Sie bereit, die Welt mit JavaFX zu begrüßen. Öffnen Sie dazu die Datei Main.java (bzw. MainApp im Maven-Projekt). Diese Klasse leitet sich von der Basisklasse javafx.application.Application ab, dem Startpunkt für alle JavaFX-Anwendungen.

Wir löschen nun den Inhalt der start-methode und ersetzen ihn durch unseren »Hello World«-Code:

Listing 1–1 Die start-Methode unserer ersten JavaFX-Anwendung

Achten Sie darauf, die richtigen Klassen zu importieren. Einige Controls gibt es mit demselben Klassennamen auch im Package java.awt, was anfangs bisweilen für Verwirrung sorgt. Die import-Sektion Ihrer Datei sollte folgende Importe enthalten:

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

Listing 1–2 Die import-Sektion

In der ersten Zeile der Methode (siehe Listing 1–1) erzeugen wir ein javafx.scene.control.Label, das einen Text anzeigt. Danach erzeugen wir einen UI-Container vom Typ javafx.scene.layout.StackPane. Das ist ein Layoutcontainer, der alle zugefügten Nodes übereinander stapelt. Er wird die Wurzel unseres SceneGraph. Wir übergeben ihn dem Konstruktor, wenn wir in der nächsten Zeile die javafx.scene.Scene erzeugen. Die anderen beiden Parameter legen Breite und Höhe der Scene fest. Aufgabe der Scene ist es, den SceneGraph zu verwalten. Der Aufrufparameter vom Typ javafx.stage.Stage ist das Fenster, in dem unser SceneGraph angezeigt wird. Wir setzen mit setTitle den Fenstertitel, übergeben mit setScene den SceneGraph und machen mit der show-Methode das Fenster sichtbar.

Starten Sie nun die Anwendung2. Sie sollten folgendes Fenster auf dem Bildschirm sehen:

Abb. 1–1 Unser erstes JavaFX-Programm

Gratuliere! Sie haben soeben Ihre erste JavaFX-Anwendung erstellt. Die Entwicklungsumgebung ist richtig konfiguriert, und nachdem diese Hürde genommen ist, können wir uns näher mit den Konzepten und APIs des UI-Toolkits befassen. Als Erstes sehen wir uns dazu den Aufbau einer JavaFX-Anwendung an.

2 Wie ist eine JavaFX-Anwendung aufgebaut?

In der »Hello World«-Anwendung sind uns bereits die wichtigsten Grundkomponenten einer JavaFX-Anwendung begegnet: Application, Stages, Scenes und Nodes. Nun sehen wir uns diese Klassen genauer an. Sie bilden die Basis aller JavaFX-Anwendungen und werden verwendet, um den SceneGraph darzustellen.

2.1 Anfang und Ende – die Application

In unserer Hallo-Welt-Anwendung haben wir bereits die Klasse Application kennengelernt, von der unsere Klasse abgeleitet ist. Diese Klasse ist vor allem dafür zuständig, mit dem Lebenszyklus der Anwendung zu interagieren.

2.1.1 Lebenszyklus einer JavaFX-Anwendung

JavaFX-Anwendungen werden vom Launcher der JavaFX Runtime gestartet und benötigen daher keine main-Methode. Der Start einer JavaFX-Anwendung sieht folgendermaßen aus:

1. Beim Start der Anwendung konstruiert die JavaFX Runtime zunächst eine Instanz der Application-Klasse und ruft dann deren init()-Methode auf. Diese Methode hat eine Leerimplementierung in der Basisklasse und muss nicht zwingend überschrieben werden.

2. Danach wird die Methode start(javafx.stage.Stage) aufgerufen, die von jeder JavaFX-Anwendung überschrieben werden muss. Der start-Methode wird eine Stage übergeben. Das ist ein Fenster, in dem wir einen SceneGraph darstellen können.

3. Wird die Anwendung beendet – zum Beispiel durch Aufruf der Methode Platform.exit() –, ruft die Runtime die Methode stop auf, bevor der Java-Prozess gestoppt wird. Auch diese Methode muss nicht zwingend überschrieben werden.

Vorsicht beim Anwendungsstart – Threading

Der JavaFX-Launcher kümmert sich darum, die Anwendung zu starten und deren Lebenszyklusmethoden init, start und stop aufzurufen. In der init-Methode können wir dann zum Beispiel die Aufrufparameter auslesen. Wir dürfen hier aber noch keine UI-Elemente erzeugen. Der Grund dafür ist, dass die init-Methode – genau wie der Konstruktor der Klasse – noch vom Launcher-Thread der Anwendung aufgerufen wird. UI-Elemente dürfen aber nur im JavaFX-Application-Thread erzeugt und modifiziert werden. Deshalb müssen wir warten, bis die start-Methode aufgerufen wird, um unser eigentliches User-Interface zu erstellen.

2.1.2 Aufrufparameter auslesen

Normalerweise bekommt man Parameter, die beim Aufruf der Anwendung auf der Kommandozeile übergeben wurden, in der main-Methode übergeben. Da es bei JavaFX-Anwendungen üblicherweise keine main-Methode gibt, übernimmt die Application diese Funktion. Um Parameter abzufragen, rufen wir einfach die Methode getParameters auf. Damit erhalten wir ein Objekt vom Typ Parameters. Von diesem Objekt können wir mit der Methode getRaw alle Parameter abfragen. Fügen Sie dazu in Ihrer Beispielanwendung die init-Methode ein:

Listing 2–1 Abfrage der Raw-Parameter

Wenn Sie nun die Anwendung über die Kommandozeile starten und dabei einen Parameter übergeben, sollte er angezeigt werden:

>java –jar /pfad/zum/HelloWorld.jar Hallo>HelloWorld Parameter: hallo

Wenn Sie ein Maven-basiertes Projekt gebaut haben, dann navigieren Sie ins Projektverzeichnis und übergeben die Parameter wie folgt.:

>mvn jfx:run -Dexec.args="hallo"

Auch die folgenden Beispiele können Sie so starten. Setzen Sie einfach alle Parameter nacheinander zwischen die Anführungsstriche.

Wir können aber auch direkt nach Schlüssel-Wert-Paaren fragen, die bei Java üblicherweise so übergeben werden:

>java –jar /pfad/zum/HelloWorld.jar --schlüssel=wert

Dazu fügen wir in der init-Methode folgenden Code hinzu:

Listing 2–2 Abfrage der Named-Parameter

Die Methode getNamed gibt uns eine Map mit Werten zurück, die unserem Parameter-Pattern entsprechen. Nun bekommen wir die Ausgabe:

>java –jar /pfad/zum/HelloWorld.jar --parameter=Bla>HelloWorld Parameter: parameter Wert: Bla

Zusätzlich können wir uns nur die Werte ausgeben lassen, die nicht diesem Schlüssel-Wert-Muster entsprechen:

Listing 2–3 Abfrage der Unnamed-Parameter

Fügen wir also unserem Aufruf einige Parameter hinzu:

>java –jar /pfad/zum/HelloWorld.jar --parameter=Bla ohne namen>Unnamed Parameter ohne>Unnamed Parameter namen

Wir können also ganz bequem und ohne Parsen alle Arten von Parametern auslesen.

2.2 Vorhang auf – die Stage

In unserer Beispielanwendung wird der start-Methode eine Stage übergeben. Dieses Anwendungsfenster können wir verwenden, um einen SceneGraph anzuzeigen. Die Namensgebung der Basisklassen Stage und Scene ist ans Theater angelehnt. Die Stage ist die Bühne, auf der eine Szene aufgeführt wird. Sie bildet den Rahmen für den eigentlichen Inhalt.

2.2.1 Dialoge anzeigen

Möchten Sie ein weiteres Fenster erzeugen, etwa einen Dialog, so geht das ganz einfach:

Listing 2–4 Anzeigen eines Fensters (Stage)

Soll der Dialog modal sein, sodass der Benutzer erst weiterarbeiten kann, wenn der Dialog wieder geschlossen ist, so kann man das mit der Methode initModality erreichen. Fügen Sie zum Testen zusätzlich diesen Code in Ihre start-Methode ein, dann sollte die Eingabe im Hauptfenster so lange blockiert sein, bis der Dialog geschlossen wurde:

Listing 2–5 Ein Fenster, das die Eingabe im Hauptfenster blockiert

2.2.2 Darstellung der Stage verändern

Die Stage bietet einige Konfigurationsmöglichkeiten für die Darstellung. In Tabelle 2–1 sind die verfügbaren Styles aufgelistet.

StageStyle

Bedeutung

DECORATED

Der Defaultwert, ein Fenster mit vom Betriebssystem abhängiger Umrandung und Bedienelementen und weißem Hintergrund

UTILITY

Minimale betriebssystemabhängige Umrandung und weißer Hintergrund

UNIFIED

Keine Border um die Scene, sodass der Betriebssystemrahmen direkt in den Toolbar übergehen kann (typisches Design bei OS X).

UNDECORATED

Ohne Umrandung mit weißem Hintergrund

TRANSPARENT

Ohne Umrandung mit transparentem Hintergrund

Tab. 2–1 Der StageStyle legt das Erscheinungsbild des Fensters fest.

Sie können die Auswirkung des StageStyle auf Ihrem Betriebssystem ganz einfach ausprobieren, indem Sie den Quellcode des »Hello World«-Programms folgendermaßen modifizieren:

Mithilfe von StageStyle.TRANSPARENT lässt sich auch eine Anwendung erzeugen, die vom üblichen rechteckigen Layout abweicht:

Listing 2–6 Erzeugen eines runden Fensters

2.2.3 Die Scene – Was wird gespielt?

JavaFX basiert auf einem SceneGraph. Dieser SceneGraph ist ein gewurzelter Baum, aufgebaut aus Nodes. Als innere Knoten gibt es Parent-Nodes, die weitere Nodes enthalten können; Blätter bestehen aus einfachen Nodes, die keine weiteren Kinder haben. Die Aufgabe der Scene ist es, den SceneGraph zu verwalten. Sie enthält den Wurzelknoten unseres Graphen, der ein Parent-Node sein muss. Die Scene ist auch das Bindeglied zwischen dem Fenster, das wir vom Betriebssystem bekommen, und unserem SceneGraph. Wird das Fenster vergrößert, so versucht die Scene, diese Änderung an den Wurzelknoten weiterzugeben. Sie ruft dazu die Methode isResizable auf dem Root-Node auf, um herauszufinden, ob der Node auf Größenänderungen reagieren möchte. Gibt der Node true zurück, wird die Scene ihn auf die neue Größe resizen, bei false lässt sie ihn in Ruhe.

2.2.4 Nodes – die Darsteller

Damit kommen wir zu den Nodes, die den Inhalt des SceneGraph bilden. Jedem Node kann eine Id zugewiesen werden, dann lässt er sich mithilfe der Methode lookup(String) der Klasse Node auffinden. Die Id kann auch für das Styling mit CSS (Cascading Stylesheets) verwendet werden, das wir in Kapitel 1 behandeln.

Parent-Nodes – Zweige im SceneGraph-Baum

Die bereits erwähnten Parent-Nodes sind die Basisklasse für alle Nodes, die weitere Nodes als Kinder enthalten. Mit ihrer Hilfe lässt sich der SceneGraph-Baum aufbauen. In unserem »Hello World«-Beispiel ist die StackPane ein solcher Parent-Node. Im Beispiel bekommen wir über die Methode getChildren einen Container, in den wir weitere Nodes, wie unseren Button, hinzufügen können. In der Basisklasse Parent ist diese Methode protected, also nur für Subklassen zugreifbar. Viele abgeleitete Klassen machen diese Methode jedoch ebenso wie die StackPane public, sodass von anderen Klassen auch Child-Nodes hinzugefügt werden können.

In der JavaFX-API gibt es mit Group und Region zwei konkrete Subklassen von Parent. Die Klasse Group ist dafür gedacht, Nodes für die Anwendung von Effekten und Transformationen zusammenzufassen. Die Klasse Region bildet die Basisklasse für alle Controls und Layouts und erweitert die Basisklasse um viele Möglichkeiten für das Styling über CSS, die wir in Kapitel 7 genauer betrachten werden.

2.3 Wie werden Layouts verwendet?

In JavaFX ist das Layout der Nodes die Aufgabe von spezialisierten Unterklassen der Klasse Region. Sie überschreiben die Methode layoutChildren der Basisklasse Parent. Während die Defaultimplementierung den Nodes nur ihre bevorzugte Größe und Position zuweist, verwenden die konkreten Subklassen jeweils einen anderen Algorithmus, um den Child-Nodes Größe und Position zuzuweisen. Kapitel 5 sehen wir uns die konkreten Strategien der eingebauten Layouts und ihre Verwendung genauer an. Um ein Layout zu verwenden, fügen wir es einem Parent hinzu oder benutzen es als Root-Node. Die StackPane, die wir in unserem Beispiel verwenden, stapelt die Nodes in der Reihenfolge ihres Hinzufügens in Z-Ordnung übereinander. Wenn wir also einen weiteren Node hinzufügen, wird er über dem Button liegend dargestellt.

2.4 Workshop: Einen Twitter-Client erstellen

Da nun die Basics geklärt sind, wollen wir das Ganze praktisch umsetzen und mit dem Bau der Beispielanwendung beginnen. Das Beispielprogramm ist ein Twitter-Client, den wir über mehrere Kapitel weiterentwickeln und verbessern werden.

Zum Bau der Anwendung verwenden wir Maven, da das von allen IDEs mehr oder weniger gut unterstützt wird und auch die Abhängigkeitsverwaltung erleichtert, wenn wir Softwarebibliotheken von Drittparteien verwenden. In unserem Projekt ist das zum Beispiel die Twitter4j-Library, die den Zugriff auf die Twitter-API erleichtert.

2.4.1 Vorbereitung

Damit das Beispiel auch funktioniert, müssen Sie zunächst Zugriff auf die Twitter-API erhalten. Dazu brauchen Sie einen Twitter-Account. Diesen erhalten Sie unter: https://twitter.com/signup.

Wir haben Twitter unter anderem deshalb gewählt, weil Twitter keine »Real Name Policy« hat, Sie müssen also nicht Ihre echten Daten angeben, um sich zu registrieren. Sie brauchen nur eine funktionierende E-Mail-Adresse. Nach der Registrierung erhalten Sie eine E-Mail mit einem Bestätigungslink.

Danach müssen Sie noch Ihre App registrieren, um die notwendigen Zugangsdaten zu erhalten. Das erledigen Sie unter https://apps.twitter.com/. Dazu klicken Sie einfach auf den Create New App-Button, dann erscheint ein kurzes Formular. Sie denken sich einen Namen für Ihre App sowie eine kurze Beschreibung aus und geben eine URL an. Keine Sorge, Sie müssen keine Domain dafür registrieren, die URL können Sie ruhig erfinden.

Außerdem benötigen Sie Maven. Falls Sie es noch nicht installiert haben, folgen Sie dazu den Instruktionen unter http://maven.apache.org/download.cgi.

Für den Fall, dass etwas nicht klappt, oder wenn Sie das Ergebnis mit der »Musterlösung« vergleichen möchten, finden Sie dieses in einem öffentlichen Git-Repository. Git ist ein Versionsverwaltungssystem, das Sie unter http://git.com installieren können. Verwenden Sie Ihre IDE oder ein Git-Tool, um das Repository http://github.com/eppleton/javafxbuch zu klonen, oder benutzen Sie dazu die Kommandozeilenaufrufe:

git clone https://github.com/eppleton/javafxbuch.git

In den einzelnen Unterordnern finden Sie jeweils den Kapiteln zugeordnete Java-Projekte mit den Programmbeispielen als Maven-Projekte. Die Beispiele sind lauffähig, allerdings müssen Sie im Falle des Twitter-Clients noch Ihre Zugangsdaten in der Datei twitter4j.properties ergänzen.

2.4.2 Die Anwendung erzeugen

Wir verwenden nun das JavaFX-Maven-Plug-in, um eine Anwendung zu erzeugen. Gehen Sie dabei vor, wie in Abschnitt 1.1.4 beschrieben, und wählen Sie unter Schritt 1 folgende Werte:

groupid: „de.javafxbuch″artifactid: „tweetalot″version: ″0.1-SNAPSHOT”package: ″de.javafxbuch.tweetalot”organizationName: ″Meine Firma”

Listing 2–7 Die Maven-Koordinaten für unser Projekt

Öffnen Sie nun die Anwendung in Ihrer bevorzugten Entwicklungsumgebung. Löschen wir zunächst alle überflüssigen Dateien. Unter den Java-Quelldateien können wir den HelloController löschen, und unter den Ressourcen (tweetalot/src/main/resources) löschen wir die Ordner fxml, images, styles und die Datei log4j.xml.

Anschließend öffnen Sie die Datei pom.xml und löschen alles zwischen dem öffnenden und schließenden <dependency>-Tag. Fügen Sie stattdessen dort diese Abhängigkeit auf Twitter4j ein:

<dependency> <groupId>org.twitter4j</groupId> <artifactId>twitter4j-core</artifactId> <version>[3.0,)</version></dependency>

Listing 2–8 Die Dependency für die twitter4j-API

Den Inhalt der Main-Klasse ersetzen Sie nun durch folgenden:

package de.javafxbuch.tweetalot;import javafx.application.Application;import javafx.stage.Stage;public class MainApp extends Application { public static void main(String[] args) throws Exception { launch(args); } public void start(Stage stage) throws Exception { }}

Listing 2–9 Das Gerüst für unsere Anwendung

Jetzt konfigurieren wir zunächst Twitter4j so, dass wir unseren Account abfragen können.

2.4.3 Mit Twitter4j auf die Timeline zugreifen

Twitter4j sucht beim Start nach einer Properties-Datei mit Ihren Zugangsdaten. Diese Datei mit Namen twitter4j.properties legen wir unter dem Pfad tweetalot/src/main/resources an. Unter den folgenden Keys müssen Sie die entsprechenden Zugangsdaten Ihrer App-Registrierung eintragen:

oauth.consumerKey= # Wert aus Ihrer App-Registrierungauth.consumerSecret= # Wert aus Ihrer App-Registrierungoauth.accessToken= # Wert aus Ihrer App-Registrierungauth.accessTokenSecret= # Wert aus Ihrer App-Registrierung

Listing 2–10 Die Zugangsdaten für die Twitter-API

Nun können Sie Twitter4j verwenden, um auf Ihre Timeline zuzugreifen und den Status anzeigen zu lassen:

Listing 2–11 Abfrage der Twitter Home-Timeline

Wenn Sie die Anwendung starten, sollten Sie nun die aktuellste Twittermeldung Ihrer Timeline sehen:

Abb. 2–1 Die erste Version unseres Twitter-Clients

Zugegeben, das sieht noch nicht toll aus, aber das werden wir in den nächsten Kapiteln verändern.

3 Properties und Bindings

Eine Aufgabe einer Benutzeroberfläche ist es, den Zustand von Datenobjekten darzustellen und dem Benutzer des Programms die Möglichkeit zu geben, diesen Zustand zu verändern. Der Benutzer bedient zum Beispiel einen Schieberegler, der die Breite eines Rechtecks regelt, und in Abhängigkeit vom eingestellten Wert muss der »width«-Wert des Datenmodells aktualisiert und die Berechnung der Rechtecksfläche neu angestoßen werden. Das kann eine Menge Code erfordern.

In einigen Programmiersprachen gibt es deshalb das Konzept von Properties, um Eigenschaften eines Datenobjekts zu repräsentieren, und Bindings, um Abhängigkeiten dieser Properties zu deklarieren. Die Synchronisierung funktioniert dann automatisch. In Java fehlen bislang echte Properties und Bindings, sodass man dafür entweder auf Programmbibliotheken von Drittparteien zurückgreifen oder sehr viel Code schreiben muss.

JavaFX führt nun endlich Properties und Bindings ein, die diese Grundaufgabe einer Benutzeroberfläche erheblich erleichtern. Diese Properties werden Ihnen überall in JavaFX begegnen. Jeder Node hat praktischerweise eine Vielzahl dieser Properties, was die Programmierung sehr erleichtert. Properties und Bindings sind ein neues Feature, mit dem JavaFX die Standard-APIs von Java erweitert. Die Anwendung ist dabei nicht auf Programme beschränkt, die ein JavaFX-GUI haben.

3.1 Beans und Properties

3.1.1 Klassische JavaBean-Properties

Sehen wir uns zunächst einmal an, wie Properties bislang modelliert wurden und wie sich JavaFX-Properties davon unterscheiden.

Listing 3–1 Eine klassische JavaBean mit einer Property

Bei einer klassischen JavaBean sind die Properties mithilfe von privaten Feldern realisiert. Auf den Wert der Felder greift man über Getter- und Setter-Methoden zu, die einer einfachen Namenskonvention folgen. Auf das Präfix get oder set folgt der Feldname beginnend mit einem Großbuchstaben. Soll auf Änderungen reagiert werden, muss die Bean eine Methode zur Verfügung stellen, um PropertyChangeListener hinzuzufügen. Bei Änderungen des Wertes über die Setter-Methode, ist diese dann dafür verantwortlich, die Listener zu informieren. Dabei wird der Listener nicht für ein bestimmtes Property registriert, sondern für alle Properties einer Bean. Er muss dann selbst anhand des Namens der Property prüfen, ob das entsprechende Event tatsächlich interessant ist oder ob er es ignorieren kann. Das ist nicht gerade elegant gelöst und zudem fehleranfällig.

3.1.2 Die neuen JavaFX-Properties

In JavaFX werden Properties etwas anders umgesetzt.

Listing 3–2 Eine JavaFX-Bean mit einer Property

Der Code ist deutlich übersichtlicher geworden. Setter und Getter behalten dieselbe Methodensignatur. Aber intern verwenden sie ein StringProperty-Objekt, um den Wert zu lesen und zu schreiben. Der Boilerplate-Code zum Aktualisieren der Listener ist weggefallen. Das übernimmt die StringProperty nämlich selbst. Alles, was wir gegenüber dem Beans-Modell lernen müssen, ist eine neue Namenskonvention: Der Name des Getters für die Property beginnt mit deren Namen gefolgt von »Property«. Der Getter für die Property mit dem Namen »age« hieße also zum Beispiel »ageProperty«. Für unsere sample-Property heißt die Methode also sampleProperty. Wenn Sie diese Bean in die Hände bekommen, dann können Sie darauf einen Listener registrieren:

myBean.sampleProperty().addListener(someListener);

Der Listener wird also für ein bestimmtes Property registriert und nicht für alle Properties der Bean. Dadurch brauchen wir keine Fallunterscheidung mehr. JavaFX-Properties sind also ein deutlicher Fortschritt gegenüber dem alten Programmiermodell.

3.1.3 Was sind die wichtigsten Klassen und Interfaces?

Bevor wir ins Detail gehen, sehen wir uns nun kurz an, welche Interfaces und APIs man kennen sollte und wie sie organisiert sind. Die wichtigsten Klassen und Interfaces, um mit Properties und Bindings zu arbeiten, stecken in den Packages javafx.beans, javafx.beans.value, javafx.collections und javafx.beans.property.

javafx.beans

In javafx.beans ist das Basis-Interface Observable definiert. Dieses Interface ist als Wrapper für einen Inhalt gedacht und erlaubt es, InvalidationListener zu registrieren. Wird der Inhalt durch eine Änderung ungültig, sodass sich abhängige Werte aktualisieren sollten, wird im registrierten Listener die Methode invalidated aufgerufen:

longProperty.addListener(new InvalidationListener() { @Override public void invalidated(Observable o) { // Reaktion auf das Ereignis }});

Listing 3–3 Hinzufügen eines Listeners

Da aber das Interface keinen Zugriff auf den Wert selbst bietet, arbeiten wir stattdessen meist mit dem Subinterface ObservableValue