Note 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.

Constructor Detail

Application

Method Detail

launch

Launch a standalone application. This method is typically called
from the main method(). It must not be called more than once or an
exception 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.
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.

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.

launch

Launch a standalone application. This method is typically called
from the main method(). It must not be called more than once or an
exception will be thrown.
This is equivalent to 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);
}

Parameters:

args - the command line arguments passed to the application.
An application may get these parameters using the
getParameters() method.

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.

init

The application initialization method. This method is called immediately
after the Application class is loaded and constructed. An application may
override this method to perform initialization prior to the actual starting
of the application.

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.

start

The main entry point for all JavaFX applications.
The start method is called after the init method has returned,
and after the system is ready for the application to begin running.

NOTE: This method is called on the JavaFX Application Thread.

Parameters:

primaryStage - the primary stage for this application, onto which
the application scene can be set. The primary stage will be embedded in
the browser if the application was launched as an applet.
Applications may create other stages, if needed, but they will not be
primary stages and will not be embedded in the browser.

notifyPreloader

Notifies the preloader with an application-generated notification.
Application code calls this method with a PreloaderNotification that is
delivered to the
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.

Parameters:

info - the application-generated preloader notification

getUserAgentStylesheet

Get the user agent stylesheet used by the whole application. This is
used to provide default styling for all ui controls and other nodes.
A value of null means the platform default stylesheet is being used.

NOTE: This method must be called on the JavaFX Application Thread.

Returns:

The URL to the stylesheet as a String.

Since:

JavaFX 8.0

setUserAgentStylesheet

Set the user agent stylesheet used by the whole application. This is used
to provide default styling for all ui controls and other nodes. Each
release of JavaFX may have a new default value for this so if you need
to guarantee consistency you will need to call this method and choose
what default you would like for your application. A value of null will
restore the platform default stylesheet. This property can also be set
on the command line with -Djavafx.userAgentStylesheetUrl=[URL]
Setting it on the command line overrides anything set using this method
in code.