public abstract class Application
extends java.lang.Object
Life-cycle
The entry point for JavaFX applications is the Application class. The JavaFX runtime does the following, in order, whenever an application is launched:
Platform.startup(Runnable)
for more information)init()
methodstart(Stage)
methodPlatform.exit()
implicitExit
attribute on Platform
is truestop()
methodNote that the start
method is abstract and must be overridden.
The init
and stop
methods have concrete implementations
that do nothing.
The Application
subclass must be declared public and must have a
public no-argument constructor.
Calling Platform.exit()
is the preferred way to explicitly terminate
a JavaFX Application. Directly calling System.exit(int)
is
an acceptable alternative, but doesn't allow the Application stop()
method to run.
A JavaFX Application should not attempt to use JavaFX after the
FX toolkit has terminated or from a ShutdownHook, that is, after the
stop()
method returns or System.exit(int)
is called.
Deploying an Application as a Module
If the Application
subclass is in a named module then that class
must be accessible to the javafx.graphics
module.
Otherwise, an exception will be thrown when the application is launched.
This means that
in addition to the class itself being declared public, the module must
export
(or open
) the containing package to
at least the javafx.graphics
module.
For example, if com.foo.MyApplication
is in the foo.app
module, the module-info.java
might look like this:
module foo.app {
exports com.foo to javafx.graphics;
}
Parameters
Application parameters are available by calling the getParameters()
method from the init()
method, or any time after the init
method has been called.
Threading
JavaFX creates an application thread for running the application start
method, processing input events, and running animation timelines. Creation
of JavaFX Scene
and Stage
objects as well as modification of
scene graph operations to live objects (those objects already
attached to a scene) must be done on the JavaFX application thread.
The Java launcher loads and initializes the specified Application class on the JavaFX Application Thread. If there is no main method in the Application class, or if the main method calls Application.launch(), then an instance of the Application is then constructed on the JavaFX Application Thread.
The init
method is called on the launcher thread, not on the
JavaFX Application Thread.
This means that an application must not construct a Scene
or a Stage
in the init
method.
An application may construct other JavaFX objects in the init
method.
All the unhandled exceptions on the JavaFX application thread that occur during
event dispatching, running animation timelines, or any other code, are forwarded
to the thread's uncaught
exception handler
.
Example
The following example will illustrate a simple JavaFX application.
import javafx.application.Application;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.shape.Circle;
import javafx.stage.Stage;
public class MyApp extends Application {
public void start(Stage stage) {
Circle circ = new Circle(40, 40, 30);
Group root = new Group(circ);
Scene scene = new Scene(root, 400, 300);
stage.setTitle("My JavaFX Application");
stage.setScene(scene);
stage.show();
}
}
The above example will produce the following:
Platform
Modifier and Type | Class and Description |
---|---|
static class |
Application.Parameters
Encapsulates the set of parameters for an application.
|
Modifier and Type | Field and Description |
---|---|
private HostServices |
hostServices |
static java.lang.String |
STYLESHEET_CASPIAN
Constant for user agent stylesheet for the "Caspian" theme.
|
static java.lang.String |
STYLESHEET_MODENA
Constant for user agent stylesheet for the "Modena" theme.
|
private static java.lang.String |
userAgentStylesheet |
Constructor and Description |
---|
Application()
Constructs a new
Application instance. |
Modifier and Type | Method and Description |
---|---|
HostServices |
getHostServices()
Gets the HostServices provider for this application.
|
Application.Parameters |
getParameters()
Retrieves the parameters for this Application, including any arguments
passed on the command line.
|
static java.lang.String |
getUserAgentStylesheet()
Get the user agent stylesheet used by the whole application.
|
void |
init()
The application initialization method.
|
static void |
launch(java.lang.Class<? extends Application> appClass,
java.lang.String... args)
Launch a standalone application.
|
static void |
launch(java.lang.String... args)
Launch a standalone application.
|
void |
notifyPreloader(Preloader.PreloaderNotification info)
Notifies the preloader with an application-generated notification.
|
static void |
setUserAgentStylesheet(java.lang.String url)
Set the user agent stylesheet used by the whole application.
|
abstract void |
start(Stage primaryStage)
The main entry point for all JavaFX applications.
|
void |
stop()
This method is called when the application should stop, and provides a
convenient place to prepare for application exit and destroy resources.
|
public static final java.lang.String STYLESHEET_CASPIAN
public static final java.lang.String STYLESHEET_MODENA
private HostServices hostServices
private static java.lang.String userAgentStylesheet
public static void launch(java.lang.Class<? extends Application> appClass, java.lang.String... args)
The launch method does not return until the application has exited,
either via a call to Platform.exit or all of the application windows
have been closed.
The class specified by the appClass
argument must be
a public subclass of Application
with a public no-argument constructor, in a package that is
exported
(or open
) to at least the
javafx.graphics
module, or a RuntimeException will be thrown.
Typical usage is:
public static void main(String[] args) { Application.launch(MyApp.class, args); }where
MyApp
is a subclass of Application.appClass
- the application class that is constructed and executed
by the launcher.args
- the command line arguments passed to the application.
An application may get these parameters using the
getParameters()
method.java.lang.IllegalStateException
- if this method is called more than once.java.lang.IllegalArgumentException
- if appClass
is not a
subclass of Application
.java.lang.RuntimeException
- if there is an error launching the
JavaFX runtime, or if the application class cannot be constructed
(e.g., if the class is not public or is not in an exported package), or
if an Exception or Error is thrown by the Application constructor, init
method, start method, or stop method.public static void launch(java.lang.String... args)
launch(TheClass.class, args)
where
TheClass
is the
immediately enclosing class of the method that called launch.
It must be a public subclass of Application
with a public no-argument constructor, in a package that is
exported
(or open
) to at least the
javafx.graphics
module, or a RuntimeException will be thrown.
The launch method does not return until the application has exited, either via a call to Platform.exit or all of the application windows have been closed.
Typical usage is:
public static void main(String[] args) { Application.launch(args); }
args
- the command line arguments passed to the application.
An application may get these parameters using the
getParameters()
method.java.lang.IllegalStateException
- if this method is called more than once.java.lang.RuntimeException
- if there is an error launching the
JavaFX runtime, or if the application class cannot be constructed
(e.g., if the class is not public or is not in an exported package), or
if an Exception or Error is thrown by the Application constructor, init
method, start method, or stop method.public void init() throws java.lang.Exception
The implementation of this method provided by the Application class does nothing.
NOTE: This method is not called on the JavaFX Application Thread. An application must not construct a Scene or a Stage in this method. An application may construct other JavaFX objects in this method.
java.lang.Exception
- if something goes wrongpublic abstract void start(Stage primaryStage) throws java.lang.Exception
NOTE: This method is called on the JavaFX Application Thread.
primaryStage
- the primary stage for this application, onto which
the application scene can be set.
Applications may create other stages, if needed, but they will not be
primary stages.java.lang.Exception
- if something goes wrongpublic void stop() throws java.lang.Exception
The implementation of this method provided by the Application class does nothing.
NOTE: This method is called on the JavaFX Application Thread.
java.lang.Exception
- if something goes wrongpublic final HostServices getHostServices()
public final Application.Parameters getParameters()
NOTE: this method should not be called from the Application constructor, as it will return null. It may be called in the init() method or any time after that.
public final void notifyPreloader(Preloader.PreloaderNotification info)
Preloader.handleApplicationNotification
method.
This is primarily useful for cases where an application wants the
preloader to show progress during a long application initialization
step.
NOTE: the notification will be delivered only to the preloader's
handleApplicationNotification() method; this means, for example, that
if this method is called with a ProgressNotification, that notification
will not be delivered to the Preloader.handleProgressNotification
method.
info
- the application-generated preloader notificationpublic static java.lang.String getUserAgentStylesheet()
NOTE: This method must be called on the JavaFX Application Thread.
public static void setUserAgentStylesheet(java.lang.String url)
-Djavafx.userAgentStylesheetUrl=[URL]
Setting it on the command line overrides anything set using this method
in code.
NOTE: This method must be called on the JavaFX Application Thread.
url
- The URL to the stylesheet as a String.