Class Application
- Direct Known Subclasses:
ActionExample1
,ActionExample2
,ActionExample3
,ActionExample4
,ApplicationExample1
,ApplicationExample2
,ExitExample1
,LocalStorageExample1
,SessionStorageExample1
,SingleFrameApplication
This class defines a simple lifecyle for Swing applications:
initialize
, startup
, ready
, and shutdown
.
The Application's
startup
method is responsible for
creating the initial GUI and making it visible, and the
shutdown
method for hiding the GUI and performing any other
cleanup actions before the application exits. The initialize
method can be used configure system properties that must be set
before the GUI is constructed and the ready
method is for applications that want to do a little bit of extra
work once the GUI is "ready" to use. Concrete subclasses must
override the startup
method.
Applications are started with the static launch
method.
Applications use the ApplicationContext
singleton
to find resources,
actions, local storage, and so on.
All Application
subclasses must override startup
and they should call exit()
(which
calls shutdown
) to exit.
Here's an example of a complete "Hello World" Application:
public class MyApplication extends Application { JFrame mainFrame = null; @Override protected void startup() { mainFrame = new JFrame("Hello World"); mainFrame.add(new JLabel("Hello World")); mainFrame.addWindowListener(new MainFrameListener()); mainFrame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE); mainFrame.pack(); mainFrame.setVisible(true); } @Override protected void shutdown() { mainFrame.setVisible(false); } private class MainFrameListener extends WindowAdapter { public void windowClosing(WindowEvent e) { exit(); } } public static void main(String[] args) { Application.launch(MyApplication.class, args); } }
The mainFrame's
defaultCloseOperation
is set
to DO_NOTHING_ON_CLOSE
because we're handling attempts
to close the window by calling
ApplicationContext
exit()
.
Simple single frame applications like the example can be defined
more easily with the SingleFrameApplication
Application
subclass.
All of the Application's methods are called (must be called) on the EDT.
All but the most trivial applications should define a ResourceBundle
in the resources subpackage with the same name as the application class (like
resources/MyApplication.properties
). This ResourceBundle contains
resources shared by the entire application and should begin with the
following the standard Application resources:
Application.name = A short name, typically just a few words Application.id = Suitable for Application specific identifiers, like file names Application.title = A title suitable for dialogs and frames Application.version = A version string that can be incorporated into messages Application.vendor = A proper name, like Sun Microsystems, Inc. Application.vendorId = suitable for Application-vendor specific identifiers, like file names. Application.homepage = A URL like http://www.javadesktop.org Application.description = One brief sentence Application.lookAndFeel = either system, default, or a LookAndFeel class name
The Application.lookAndFeel
resource is used to initialize the
UIManager lookAndFeel
as follows:
system
- the system (native) look and feeldefault
- use the JVM default, typically the cross platform look and feel- a LookAndFeel class name - use the specified class
- See Also:
-
Nested Class Summary
Nested ClassesModifier and TypeClassDescriptionstatic interface
Give the Application a chance to veto an attempt to exit/quit. -
Constructor Summary
Constructors -
Method Summary
Modifier and TypeMethodDescriptionvoid
addExitListener
(Application.ExitListener listener) Add anExitListener
to the list.protected void
end()
Called byexit
to terminate the application.final void
exit()
Gracefully shutdown the application, callsexit(null)
This version of exit() is convenient if the decision to exit the application wasn't triggered by an event.void
exit
(EventObject event) Gracefully shutdown the application.final ApplicationContext
The ApplicationContext singleton for this Application.All of theExitListeners
added so far.static Application
TheApplication
singleton, or a placeholder iflaunch
hasn't been called yet.static <T extends Application>
TgetInstance
(Class<T> applicationClass) TheApplication
singleton.void
protected void
initialize
(String[] args) Responsible for initializations that must occur before the GUI is constructed bystartup
.static <T extends Application>
voidCreates an instance of the specifiedApplication
subclass, sets theApplicationContext
application
property, and then calls the newApplication's
startup
method.void
quit
(ActionEvent e) The defaultAction
for quitting an application,quit
just exits the application by callingexit(e)
.protected void
ready()
Called after the startup() method has returned and there are no more events on thesystem event queue
.void
removeExitListener
(Application.ExitListener listener) Remove anExitListener
from the list.void
protected void
shutdown()
Called when the applicationexits
.protected abstract void
startup()
Responsible for starting the application; for creating and showing the initial GUI.Methods inherited from class org.jdesktop.application.AbstractBean
addPropertyChangeListener, addPropertyChangeListener, firePropertyChange, firePropertyChange, getPropertyChangeListeners, removePropertyChangeListener, removePropertyChangeListener
-
Constructor Details
-
Application
protected Application()
-
-
Method Details
-
launch
Creates an instance of the specifiedApplication
subclass, sets theApplicationContext
application
property, and then calls the newApplication's
startup
method. Thelaunch
method is typically called from the Application'smain
:public static void main(String[] args) { Application.launch(MyApplication.class, args); }
TheapplicationClass
constructor andstartup
methods run on the event dispatching thread.- Parameters:
applicationClass
- theApplication
class to launchargs
-main
method arguments- See Also:
-
initialize
Responsible for initializations that must occur before the GUI is constructed bystartup
.This method is called by the static
launch
method, beforestartup
is called. Subclasses that want to do any initialization work beforestartup
must override it. Theinitialize
method runs on the event dispatching thread.By default initialize() does nothing.
- Parameters:
args
- the main method's arguments.- See Also:
-
startup
protected abstract void startup()Responsible for starting the application; for creating and showing the initial GUI.This method is called by the static
launch
method, subclasses must override it. It runs on the event dispatching thread.- See Also:
-
ready
protected void ready()Called after the startup() method has returned and there are no more events on thesystem event queue
. When this method is called, the application's GUI is ready to use.It's usually important for an application to start up as quickly as possible. Applications can override this method to do some additional start up work, after the GUI is up and ready to use.
- See Also:
-
shutdown
protected void shutdown()Called when the applicationexits
. Subclasses may override this method to do any cleanup tasks that are neccessary before exiting. Obviously, you'll want to try and do as little as possible at this point. This method runs on the event dispatching thread.- See Also:
-
exit
public final void exit()Gracefully shutdown the application, callsexit(null)
This version of exit() is convenient if the decision to exit the application wasn't triggered by an event.- See Also:
-
exit
Gracefully shutdown the application.If none of the
ExitListener.canExit()
methods return false, calls theExitListener.willExit()
methods, thenshutdown()
, and then exits the Application withend
. Exceptions thrown while running willExit() or shutdown() are logged but otherwise ignored.If the caller is responding to an GUI event, it's helpful to pass the event along so that ExitListeners' canExit methods that want to popup a dialog know on which screen to show the dialog. For example:
class ConfirmExit implements Application.ExitListener { public boolean canExit(EventObject e) { Object source = (e != null) ? e.getSource() : null; Component owner = (source instanceof Component) ? (Component)source : null; int option = JOptionPane.showConfirmDialog(owner, "Really Exit?"); return option == JOptionPane.YES_OPTION; } public void willExit(EventObejct e) {} } myApplication.addExitListener(new ConfirmExit());
TheeventObject
argument may be null, e.g. if the exit call was triggered by non-GUI code, andcanExit
,willExit
methods must guard against the possibility that theeventObject
argument'ssource
is not aComponent
.- Parameters:
event
- the EventObject that triggered this call or null- See Also:
-
end
protected void end()Called byexit
to terminate the application. CallsRuntime.getRuntime().exit(0)
, which halts the JVM.- See Also:
-
addExitListener
Add anExitListener
to the list.- Parameters:
listener
- theExitListener
- See Also:
-
removeExitListener
Remove anExitListener
from the list.- Parameters:
listener
- theExitListener
- See Also:
-
getExitListeners
All of theExitListeners
added so far.- Returns:
- all of the
ExitListeners
added so far.
-
quit
The defaultAction
for quitting an application,quit
just exits the application by callingexit(e)
.- Parameters:
e
- the triggering event- See Also:
-
getContext
The ApplicationContext singleton for this Application.- Returns:
- the Application's ApplicationContext singleton
-
getInstance
TheApplication
singleton.Typically this method is only called after an Application has been launched however in some situations, like tests, it's useful to be able to get an
Application
object without actually launching. In that case, an instance of the specified class is constructed and configured as it would be by thelaunch
method. However it'sinitialize
andstartup
methods are not run.- Parameters:
applicationClass
- this Application's subclass- Returns:
- the launched Application singleton.
- See Also:
-
getInstance
TheApplication
singleton, or a placeholder iflaunch
hasn't been called yet.Typically this method is only called after an Application has been launched however in some situations, like tests, it's useful to be able to get an
Application
object without actually launching. The placeholder Application object provides access to anApplicationContext
singleton and has the same semantics as launching an Application defined like this:public class PlaceholderApplication extends Application { public void startup() { } } Application.launch(PlaceholderApplication.class);
- Returns:
- the Application singleton or a placeholder
- See Also:
-
show
-
hide
-