 Outline

7.1. Introduction
7.2. GUI components
7.3. Layout Management
7.4. Event handling
7.5. Deployment
 A graphical user interface (GUI) presents a user-
friendly mechanism for interacting with an application.
◦ Pronounced “GOO-ee”
◦ Gives an application a distinctive “look-and-feel.”
◦ Consistent, intuitive user-interface components give users a
sense of familiarity
◦ Learn new applications more quickly and use them more
productively.
 Built from GUI components.
◦ Sometimes called controls or widgets—short for window gadgets.
 User interacts via the mouse, the keyboard or another
form of input, such as voice recognition.
 IDEs
◦ Provide GUI design tools to specify a component’s size, location
and other attributes in a visual manner by using the mouse,
keyboard and drag-and-drop.
◦ Generate the GUI code for you.
◦ Greatly simplify creating GUIs, but each IDE has different
capabilities and generates different code.
 Example of a GUI: SwingSet3 application (Fig. 12.1)
http://www.oracle.com/technetwork/java/javase/
downloads/index.html
 title bar at top contains the window’s title.
 menu bar contains menus (File and View).
 In the top-right region of the window is a set of buttons
◦ Typically, users press buttons to perform tasks.
 In the GUI Components area of the window is a combo
box;
◦ User can click the down arrow at the right side of the box to select
from a list of items.
7.2. GUI components
 Most applications use windows or dialog boxes (also called
dialogs) to interact with the user.
 JOptionPane (package javax.swing) provides
prebuilt dialog boxes for input and output
◦ Displayed via static JOptionPane methods.
 Figure 12.2 uses two input dialogs to obtain integers from
the user and a message dialog to display the sum of the
integers the user enters.
 JOptionPane static method
showInputDialog displays an input dialog, using
the method’s String argument as a prompt.
◦ The user types characters in the text field, then clicks
OK or presses the Enter key to submit the String to
the program.
◦ Clicking OK dismisses (hides) the dialog.
◦ Can input only Strings. Typical of most GUI
components.
◦ If the user clicks Cancel, returns null.
◦ JOptionPane dialog are dialog—the user cannot
interact with the rest of the application while dialog is
displayed.
 Converting Strings to int Values
◦ Integer class’s static method parseInt converts its
String argument to an int value and might throw a
NumberFormatException.
 Message Dialogs
◦ JOptionPane static method showMessageDialog
displays a message dialog.
◦ The first argument helps determine where to position the
dialog.
 If null, the dialog box is displayed at the center of your screen.
◦ The second argument is the message to display.
◦ The third argument is the String that should appear in the
title bar at the top of the dialog.
◦ The fourth argument is the type of message dialog to display.
 Swing GUI components located in package
javax.swing.
 Abstract Window Toolkit (AWT) in package java.awt is
another set of GUI components in Java.
 Together, the appearance and the way in which the user interacts
with the application are known as that application’s look-and-
feel.
 Swing GUI components allow you to specify a uniform look-
and-feel for your application across all platforms or to use each
platform’s custom look-and-feel.
 Most Swing components are not tied to actual GUI
components of the underlying platform.
◦ Known as lightweight components.
 AWT components are tied to the local platform and are
called heavyweight components, because they rely on the
local platform’s windowing system to determine their
functionality and their look-and-feel.
 Class Component (package java.awt) declares
many of the attributes and behaviors common to the
GUI components in packages java.awt and
javax.swing.
 Most GUI components extend class Component
directly or indirectly.
 Class Container (package java.awt) is a
subclass of Component.
 Components are attached to Containers so that
they can be organized and displayed on the screen.
 Any object that is a Container can be used to
organize other Components in a GUI.
 Because a Container is a Component, you can
place Containers in other Containers to help
organize a GUI.
 Class JComponent (package javax.swing) is a
subclass of Container.
 JComponent is the superclass of all lightweight

Swing components, all of which are also

Containers.
 Some common lightweight component
features supported by JComponent include:
◦ pluggable look-and-feel
◦ Shortcut keys (called mnemonics)
◦ Common event-handling capabilities for components
that initiate the same actions in an application.
◦ tool tips
◦ Support for accessibility
◦ Support for user-interface localization
 Most windows that can contain Swing GUI components are
instances of class JFrame or a subclass of JFrame.
 JFrame is an indirect subclass of class
java.awt.Window
 Provides the basic attributes and behaviors of a window
◦ a title bar at the top
◦ buttons to minimize, maximize and close the window
 Most of our examples will consist of two classes
◦ a subclass of JFrame that demonstrates new GUI concepts
◦ an application class in which main creates and displays the
application’s primary window.
 In a large GUI
◦ Difficult to identify the purpose of every component.
◦ Provide text stating each component’s purpose.
 Such text is known as a label and is created with class
JLabel—a subclass of JComponent.
◦ Displays read-only text, an image, or both text and an image.
 JFrame’s constructor uses its String argument as the
text in the window’s title bar.
 Must attach each GUI component to a container, such as a
JFrame.
 You typically must decide where to position each GUI
component.
◦ Known as specifying the layout of the GUI components.
◦ Java provides several layout managers that can help you position
components.
 Many IDEs provide GUI design tools in which you can
specify the exact size and location of a component
 IDE generates the GUI code for you
 Greatly simplifies GUI creation
 To ensure that this book’s examples can be used with any
IDE, we did not use an IDE to create the GUI code
 We use Java’s layout managers in our GUI examples
 FlowLayout
◦ GUI components are placed in a container from left to right
in the order in which the program attaches them to the
container.
◦ When there is no more room to fit components left to right,
components continue to display left to right on the next line.
◦ If the container is resized, a FlowLayout reflows the
components to accommodate the new width of the container,
possibly with fewer or more rows of GUI components.
 Method setLayout is inherited from class
Container.
◦ argument must be an object of a class that implements the
LayoutManager interface (e.g., FlowLayout).
 JLabel constructor can receive a String specifying the
label’s text.
 Method setToolTipText (inherited by JLabel from
JComponent) specifies the tool tip that is displayed when
the user positions the mouse cursor over a JComponent
(such as a JLabel).
 You attach a component to a container using the add
method, which is inherited indirectly from class
Container.
 Icons enhance the look-and-feel of an application and are
also commonly used to indicate functionality.
 An icon is normally specified with an Icon (package
javax.swing) argument to a constructor or to the
component’s setIcon method.
 ImageIcon (package javax.swing) supports several
image formats, including Graphics Interchange Format
(GIF), Portable Network Graphics (PNG) and Joint
Photographic Experts Group (JPEG).
 getClass().getResource("bug1.png")
◦ Invokes method getClass (inherited indirectly from class
Object) to retrieve a reference to the Class object that
represents the LabelFrame class declaration.
◦ Next, invokes Class method getResource, which
returns the location of the image as a URL.
◦ The ImageIcon constructor uses the URL to locate the
image, then loads it into memory.
◦ The class loader knows where each class it loads is located
on disk. Method getResource uses the Class object’s
class loader to determine the location of a resource, such as
an image file.
 A JLabel can display an Icon.
 JLabel constructor can receive text and an Icon.
◦ The last constructor argument indicates the justification of the
label’s contents.
◦ Interface SwingConstants (package javax.swing)
declares a set of common integer constants (such as
SwingConstants.LEFT, SwingConstants.CENTER
and SwingConstants.RIGHT) that are used with many
Swing components.
◦ By default, the text appears to the right of the image when a
label contains both text and an image.
◦ The horizontal and vertical alignments of a JLabel can be
set with methods setHorizontalAlignment and
setVerticalAlignment, respectively.
 Class JLabel provides methods to change a JLabel’s
appearance after it has been instantiated.
 Method setText sets the text displayed on the label.
 Method getText retrieves  the JLabel’s current text.
 Method setIcon specifies the Icon to display.
 Method getIcon retrieves  the current Icon displayed
on a label.
 Methods setHorizontalTextPosition and
setVerticalTextPosition specify the text
position in the label.
 By default, closing a window simply hides the window.
 Calling method setDefaultCloseOperation (inherited
from class JFrame) with the argument
JFrame.EXIT_ON_CLOSE indicates that the program should
terminate when the window is closed by the user.
 Method setSize specifies the width and height of the window
in pixels.
 Method setVisible with the argument true displays the
window on the screen.
 Layout managers arrange GUI components in a container
for presentation purposes
 Can use for basic layout capabilities
 Enable you to concentrate on the basic look-and-feel—the
layout manager handles the layout details.
 Layout managers implement interface LayoutManager
(in package java.awt).
 Container’s setLayout method takes an object that
implements the LayoutManager interface as an
argument.
 There are three ways for you to arrange components
in a GUI:
◦ Absolute positioning
 Greatest level of control.
 Set Container’s layout to null.
 Specify the absolute position of each GUI component with
respect to the upper-left corner of the Container by
using Component methods setSize and
setLocation or setBounds.
 Must specify each GUI component’s size.
◦ Layout managers
 Simpler and faster than absolute positioning.
 Makes your GUIs more resizable.
 Lose some control over the size and the precise
positioning of each component.
◦ Visual programming in an IDE
 Use tools that make it easy to create GUIs.
 Allows you to drag and drop GUI components from a tool
box onto a design area.
 You can then position, size and align GUI components as
you like.
 FlowLayout is the simplest layout manager.
 GUI components placed from left to right in the order in
which they are added to the container.
 When the edge of the container is reached, components
continue to display on the next line.
 FlowLayout allows GUI components to be left aligned,
centered (the default) and right aligned.
 FlowLayout method setAlignment changes the
alignment for the FlowLayout.
◦ FlowLayout.LEFT
◦ FlowLayout.CENTER
◦ FlowLayout.RIGHT
 LayoutManager interface method layoutContainer
(which is inherited by all layout managers) specifies that a
container should be rearranged based on the adjusted layout.
 BorderLayout
◦ the default layout manager for a Jframe
◦ arranges components into five regions: NORTH, SOUTH,
EAST, WEST and CENTER.
◦ NORTH corresponds to the top of the container.
 BorderLayout implements interface
LayoutManager2 (a subinterface of
LayoutManager that adds several methods for
enhanced layout processing).
 BorderLayout limits a Container to at most
five components—one in each region.
◦ The component placed in each region can be a container to
which other components are attached.
 BorderLayout constructor arguments specify the
number of pixels between components that are
arranged horizontally (horizontal gap space) and
between components that are arranged vertically
(vertical gap space), respectively.
◦ The default is one pixel of gap space horizontally and
vertically.
 GridLayout divides the container into a grid of
rows and columns.
◦ Implements interface LayoutManager.
◦ Every Component has the same width and height.
◦ Components are added starting at the top-left cell of the grid
and proceeding left to right until the row is full. Then the
process continues left to right on the next row of the grid,
and so on.
 Container method validate recomputes the
container’s layout based on the current layout
manager and the current set of displayed GUI
components.
7.4 Event handling
 GUIs are event driven.
 When the user interacts with a GUI component, the

interaction—known as an event—drives the program to

perform a task.
 The code that performs a task in response to an event is

called an event handler, and the process of responding

to events is known as event handling.
 JTextFields and JPasswordFields (package
javax.swing).
 JTextField extends class JTextComponent (package
javax.swing.text), which provides many features
common to Swing’s text-based components.
 Class JPasswordField extends JTextField and adds
methods that are specific to processing passwords.
 JPasswordField shows that characters are being typed as the
user enters them, but hides the actual characters with an echo
character.
 When the user types data into a JTextField or a
JPasswordField, then presses Enter, an event
occurs.
 You can type only in the text field that is “in focus.”
 A component receives the focus when the user clicks

the component.
 Before an application can respond to an event for a
particular GUI component, you must perform several
coding steps:
 Create a class that represents the event handler.
 Implement an appropriate interface, known as an event-
listener interface, in the class from Step 1.
 Indicate that an object of the class from Steps 1 and 2
should be notified when the event occurs. This is known
as registering the event handler.
 All the classes discussed so far were so-called top-level
classes—that is, they were not declared inside another
class.
 Java allows you to declare classes inside other classes

—these are called nested classes.

◦ Can be static or non-static.
◦ Non-static nested classes are called inner classes and are
frequently used to implement event handlers.
 Before an object of an inner class can be created, there must first
be an object of the top-level class that contains the inner class.
 This is required because an inner-class object implicitly has a
reference to an object of its top-level class.
 There is also a special relationship between these objects—the
inner-class object is allowed to directly access all the variables
and methods of the outer class.
 A nested class that is static does not require an object of its
top-level class and does not implicitly have a reference to an
object of the top-level class.
 Inner classes can be declared public, protected
or private.
 Since event handlers tend to be specific to the

application in which they are defined, they are often

implemented as private inner classes.
 GUI components can generate many events in response
to user interactions.
 Each event is represented by a class and can be

processed only by the appropriate type of event

handler.
 Normally, a component’s supported events are

described in the Java API documentation for that

component’s class and its superclasses.
 When the user presses Enter in a JTextField or
JPasswordField, an ActionEvent (package
java.awt.event) occurs.
 Processed by an object that implements the interface
ActionListener (package java.awt.event).
 To handle ActionEvents, a class must implement
interface ActionListener and declare method
actionPerformed.
◦ This method specifies the tasks to perform when an ActionEvent
occurs.
 Must register an object as the event handler for each
text field.
 addActionListener registers an

ActionListener object to handle

ActionEvents.
 After an event handler is registered the object listens

for events.
 The component with which the user interacts is the event
source.
 ActionEvent method getSource (inherited from class
EventObject) returns a reference to the event source.
 ActionEvent method getActionCommand obtains
the text the user typed in the text field that generated the
event.
 JPasswordField method getPassword returns the
password’s characters as an array of type char.
 A button is a component the user clicks to trigger a
specific action.
 Several types of buttons
◦ command buttons
◦ checkboxes
◦ toggle buttons
◦ radio buttons
 Button types are subclasses of AbstractButton
(package javax.swing), which declares the
common features of Swing buttons.
 A command button generates an ActionEvent when
the user clicks it.
 Command buttons are created with class JButton.
 The text on the face of a JButton is called a button

label.
 A JButton can display an Icon.
 A JButton can also have a rollover Icon
◦ displayed when the user positions the mouse over the JButton.
◦ The icon on the JButton changes as the mouse moves in and out
of the JButton’s area on the screen.
 AbstractButton method setRolloverIcon
specifies the image displayed on the JButton when the
user positions the mouse over it.
 Three types of state buttons—JToggleButton,
JCheckBox and JRadioButton—that have on/off
or true/false values.
 Classes JCheckBox and JRadioButton are
subclasses of JToggleButton.
 JRadioButtons are grouped together and are
mutually exclusive—only one in the group can be
selected at any time
 JTextField method setFont (inherited by
JTextField indirectly from class Component) sets the
font of the JTextField to a new Font (package
java.awt).
 String passed to the JCheckBox constructor is the
checkbox label that appears to the right of the JCheckBox
by default.
 When the user clicks a JCheckBox, an ItemEvent occurs.
◦ Handled by an ItemListener object, which must implement method
itemStateChanged.
 An ItemListener is registered with method
addItemListener.
 JCheckBox method isSelected returns true if a
JCheckBox is selected.
 Radio buttons (declared with class JRadioButton)
are similar to checkboxes in that they have two states
—selected and not selected (also called deselected).
 Radio buttons normally appear as a group in which
only one button can be selected at a time.
 Used to represent mutually exclusive options.
 The logical relationship between radio buttons is
maintained by a ButtonGroup object (package
javax.swing), which organizes a group of buttons
and is not itself displayed in a user interface.
 ButtonGroup method add associates a
JRadioButton with the group.
 If more than one selected JRadioButton object is

added to the group, the selected one that was added

first will be selected when the GUI is displayed.
 JRadioButtons, like JCheckBoxes, generate

ItemEvents when they are clicked.

 A combo box (sometimes called a drop-down list)
enables the user to select one item from a list.
 Combo boxes are implemented with class

JComboBox, which extends class JComponent.

 JComboBoxes generate ItemEvents.
 The first item added to a JComboBox appears as the
currently selected item when the JComboBox is
displayed.
 Other items are selected by clicking the JComboBox,
then selecting an item from the list that appears.
 JComboBox method setMaximumRowCount sets the
maximum number of elements that are displayed when
the user clicks the JComboBox.
 If there are additional items, the JComboBox provides a
scrollbar that allows the user to scroll through all the
elements in the list.
 An anonymous inner class is an inner class that is declared
without a name and typically appears inside a method
declaration.
 As with other inner classes, an anonymous inner class can
access its top-level class’s members.
 An anonymous inner class has limited access to the local
variables of the method in which it’s declared.
 Since an anonymous inner class has no name, one object of
the anonymous inner class must be created at the point
where the class is declared.
 JComboBox method getSelectedIndex returns
the index of the selected item.
 For each item selected from a JComboBox, another
item is first deselected—so two ItemEvents occur
when an item is selected.
 ItemEvent method getStateChange returns the
type of state change. ItemEvent.SELECTED
indicates that an item was selected.
 In Section 17.9, we show how to use Java SE 8 lambdas
to create event handlers.
◦ The compiler translates a lambda into an object of an
anonymous inner class.
 A list displays a series of items from which the user
may select one or more items.
 Lists are created with class JList, which directly
extends class JComponent.
 Class JList—which like JComboBox is a generic
class—supports single-selection lists (only one item to
be selected at a time) and multiple-selection lists (any
number of items to be selected).
 JLists generate ListSelectionEvents in
single-selection lists.
 setVisibleRowCount specifies the number of items
visible in the list.
 setSelectionMode specifies the list’s selection mode.
 Class ListSelectionModel (of package
javax.swing) declares selection-mode constants
◦ SINGLE_SELECTION (only one item to be selected at a
time)
◦ SINGLE_INTERVAL_SELECTION (allows selection of
several contiguous items)
◦ MULTIPLE_INTERVAL_SELECTION (does not restrict
the items that can be selected).
 Unlike a JComboBox, a JList does not provide a
scrollbar if there are more items in the list than the
number of visible rows.
◦ A JScrollPane object is used to provide the scrolling
capability.
 addListSelectionListener registers a
ListSelectionListener (package
javax.swing.event) as the listener for aJList’s
selection events.
 Each JFrame actually consists of three layers—the
background, the content pane and the glass pane.
 The content pane appears in front of the background and is
where the GUI components in the JFrame are displayed.
 The glass pane is displays tool tips and other items that should
appear in front of the GUI components on the screen.
 The content pane completely hides the background of the
JFrame.
 To change the background color behind the GUI components,
you must change the content pane’s background color.
 Method getContentPane returns a reference to the
JFrame’s content pane (an object of class Container).
 List method getSelectedIndex returns the selected
item’s index.
 A multiple-selection list enables the user to select many
items from a JList.
 A SINGLE_INTERVAL_SELECTION list allows
selecting a contiguous range of items.
◦ To do so, click the first item, then press and hold the Shift key
while clicking the last item in the range.
 A MULTIPLE_INTERVAL_SELECTION list (the
default) allows continuous range selection as described
for a SINGLE_INTERVAL_SELECTION list and allows
miscellaneous items to be selected by pressing and
holding the Ctrl key while clicking each item to select.
◦ To deselect an item, press and hold the Ctrl key while clicking
the item a second time.
 If a JList does not contain items it will not diplay in
a FlowLayout.
◦ use JList methods setFixedCellWidth and
setFixedCellHeight to set the item width and height
 There are no events to indicate that a user has made
multiple selections in a multiple-selection list.
◦ An event generated by another GUI component (known as an
external event) specifies when the multiple selections in a
JList should be processed.
 Method setListData sets the items displayed in a
JList.
 Method getSelectedValues returns an array of
Objects representing the selected items in a JList.