[JAVA][Beginning Java 8 Games Development]

Chapter 4 ■ An Introduction to JavaFX 8: Exploring the Capabilities of the Java 8 Multimedia Engine
A Worker object performs processing, using a background thread, and can be either reusable (such as in the
Service class) or not reusable (such as in the Task class). Worker thread states are controlled by the Worker.State
class (object) and contain the life cycle stages for a Worker thread. These apply across the three primary classes in
the javafx.concurrent package, as they implement the Worker interface and its related nested classes. As mentioned
in the previous chapter, a nested class is accessed via dot notation, so the State class is thus nested inside the Worker
interface (class). Because the states of a Worker thread are very important to understand before you use it, I am
going to detail them in the form of a table so that they are crystal clear to you (see Table 4-3).
Table 4-3. Worker Thread Life Cycle States, as Defined by the Worker.State Nested Class for Use with a Worker Interface
Worker.State Constant
READY
SCHEDULED
RUNNING
SUCCEEDED
FAILED
CANCELLED
Significance
Worker object (thread) has been initialized (or reinitialized) and is ready to be used.
Worker object (thread) has been scheduled for execution but is not currently running.
Worker object (thread) is currently running and is executing the Java programming logic.
Worker object (thread) has executed successfully, and a valid result is in the value property.
Worker object (thread) has failed to execute successfully because of some
unexpected condition.
Worker object (thread) has been cancelled by invoking the Worker.cancel() method call.
As with everything else in this JavaFX 8 multimedia engine overview chapter, you will be getting deep into the
details of how to use these packages, classes, nested classes, interfaces, methods, constants, and variables over the
course of the book, as you apply these JavaFX programming constructs and concepts!
Summary
In this fourth chapter, you took a closer look at some of the more important packages, concepts, components, classes,
constructors, constants, and variables (attributes) that can be found in the JavaFX 8 API, an impressive collection of
36 javafx.packagename.subpackagename packages, which I outlined in tables and covered, one by one, as needed for
multimedia 2D and 3D (and hybrid 2D-3D) game development. When I say, “an overview,” I mean an overview!
Certainly, I cannot discuss every functional class in JavaFX in one chapter, so I started with a broad overview of
the JavaFX engine and how it integrates with the JavaFX Scene Builder tool and the JavaFX Scene Graph API above
it, and with the Java 8 API, NetBeans 8.0, and target OSs below it, which give JavaFX expansive OS support across so
many popular platforms and devices and the leading web browsers.
I presented a high-level technical view of JavaFX, detailing its structures, including JavaFX Scene Graph, APIs,
Quantum, Prism, Glass, WebKit, and Media engine. You looked at how these multithreading, rendering, windowing,
media, and web engines interface with the Java 8 API and Java JDK 8 as well as with NetBeans 8.0 and the JVM
bytecode that it generates, which is read by all the various OS platforms currently running across a dozen different
consumer electronics device types.
You also explored JavaFX core concepts, such as the JavaFX Scene Graph and the JavaFX pulse events system,
which you will be leveraging to create a Java 8 game as you work through this book, starting in the next chapter, when I
explain how to use the JavaFX Scene Builder visual editing tool in NetBeans.
Then, you dove deep into some of the key JavaFX packages and subpackages for game design, such as
Application, Scene, Shape, Effect, Layout, Control, Media, Image, Stage, Animation, Geometry, Event,
and Concurrent, and their package classes and subclasses and even, in some cases, their interfaces, nested classes,
and constants.
98
www.it-ebooks.info