A GUI program is composed AWT Components &

of three types of software: Containers

-Graphical components that
make up the Graphical User
JAVA GUI
Interface
GUI -Listener methods that
• stands for Graphical receive the events and
User Interface respond to them

• program interface that -Application methods that

takes advantage of perform the desired
the computer’s operations on the Swing
graphics capabilities information.
-graphical user interface
to make the program Abstract Window Toolkit toolkit in Java, which is one
easier to use
Java’s platform-independent part of the Java Foundation
• designed in 1970 by Classes (JFC)
windowing, graphics, and
Xerox Corporation’s user-interface widget toolkit -includes graphical user
Palo Alto Research
• part of the Java interface (GUI) widgets such
Center
Foundation Classes as text boxes, buttons, split-
• Basic Components: panes, and tables
(JFC) – the standard
• Pointer API (Application -runs the same on all
Program Interface) for platforms
• Pointing device providing graphical
user interfaces for -supports pluggable look and
• Icons
Java programs feel – not by using the native
• Desktop platform's facilities, but by
• contains the roughly emulating them
• Windows fundamental classes
used for constructing -classes are often described
• Menu
GUIs as lightweight because they
• In Java, GUI-based do not require allocation of
programs are AWT Hierarchy native resources in the
implemented by using operating system’s window
the classes from the toolkit
standard javax.swing -UI elements such as dialog
(Swing classes) and boxes and buttons; you can
java.awt (AWT usually recognize their
classes) packages.
names because they begin
• All GUI classes are with J
based on the -Each Swing component is a
fundamental classes descendant of a
in the Application
JComponent, which in turn
Windowing Toolkit or
inherits from the
AWT. java.awt.Container class
 • You insert the import
statement
import javax.swing.*;
at the beginning of your Java
program files so you can
take advantage of the Swing
UI components and their
methods
JFrame Class
-contains the most basic
functionalities that support
features found in any frame
window, such as minimizing
the window, moving the
window, and resizing the
window
-To design such a frame
window, we define a
subclass of the JFrame
class and add methods and
data members that
implement the needed
functionalities.
JFrame Class Methods
void setTitle(String) - Sets a
JFrame’s title to the String
argument
void setSize(Dimension)-
Sets a JFrame’s size using a
Dimension class object; the
Dimension(int, int) constructor
creates an object that
represents both a width and a
height
String getTitle()- Returns a
JFrame’s title
void
setResizable(boolean)-Sets
the JFrame to be resizable
by passing true to the
method, or sets the JFrame
to be not resizable by
passing false to the method
boolean isResizable()-
Returns true or false to
indicate whether the JFrame
is resizable
void setVisible(boolean)-
Sets a JFrame to be visible
using the boolean argument
true and invisible using the
boolean argument false
void setBounds(int, int, int,
int)-Overrides the default
behavior of the JFrame to be
positioned in the upper- left
corner of the computer
screen’s desktop. The first
two arguments are the
horizontal and vertical
positions of the JFrame’s
upper-left corner on the
desktop. The final two
arguments set the width and
height.
JFrame Class
When a JFrame serves as a
Swing application’s main
user interface, you usually
want the program to exit
when the user clicks Close.
To change this behavior, you
can call a JFrame’s
setDefaultCloseOperation()
method and use one of the
following four values as an
argument:
JFrame.EXIT_ON_CLOSE
exits the program when the
JFrame is closed.
WindowConstants.DISPOS
E_ON_CLOSE closes the
frame, disposes of the
JFrame object, and keeps
running the application.
WindowConstants.DO_NO
THING_ON_CLOSE keeps
the JFrame and continues
running. In other words,
it functionally disables the
Close button.
WindowConstants.HIDE_O
N_CLOSE closes the
JFrame and continues
running; this is the default
operation that you frequently
want to override.
JPanel Class
The simplest Swing
container
Plain, borderless surface that
can hold lightweight UI
components, such as
JButton, JCheckBoxes, or
even other JPanels.
Inheritance Hierarchy of the
JPanel Class.
• To add a component
to a JPanel, the
container’s add()
method is called,
using the component
as the argument.
• In using a JPanel to
hold components, the
setContentPane()
method is also used
to allow the JPanel to
be set as a content
pane so it can hold
components.
EVENTS AND EVENT Common user actions and
HANDLING the events that are
generated from them
In Java, events represent all
activity that goes on between User Action
the user and the application.
Resulting Event Type
• Like all Java classes,
events are Objects Click a button
that the user initiates. ActionEvent
The parent class for all event Click a component
objects is named
EventObject, which MouseEvent
descends from the Object Click an item in a list box
class.
ItemEvent
EventObject is the parent of
AWTEvent, which in turn is Click an item in a check
the parent of specific event box
classes such as
ItemEvent
ActionEvent and
ComponentEvent. Change text in a text field
TextEvent
Open a window
WindowEvent
Iconify a window
WindowEvent
Press a key
KeyEvent
When you write programs
with GUI interfaces, you are
always handling events that
originate with the mouse or
keys on specific
Components or Containers.
Event Listener
Object that includes a
method that gets executed in
response to the generated
events
Event listeners and the types
of events for which they are
used.
Listener-Type of Events
Example
ActionListener-Action events
Button clicks
AdjustmentListener-
Adjustment events
Scroll bar moves
ChangeListener-Change
Events
Slider is repositioned
FocusListener-Keyboard
focus events
Text field gains or loses
focus
ItemListener-Item events
Check box changes status
KeyListener-Keyboard
events
Text is entered
MouseListener-Mouse
events
Mouse clicks
MouseMotionListener-Mouse
movement events
Mouse rolls
WindowListener-Window
events
Window closes
• Any object can be
notified of an event as
long as it implements
the appropriate
interface and is
registered as an event
listener of the
appropriate event
source.
• The class of the
object that responds
to an event must
contain a method that
accepts the event
object created by the
user’s action. Mouse Event
• In other words, when The MouseMotionListener
you register a interface provides methods
component (such as named mouseDragged()
JFrame) to be a and mouseMoved() that
listener for events detect the mouse being
generated by another rolled or dragged across a
component (such as a component surface.
JCheckBox), you
need to write a The MouseListener
method that reacts to interface provides methods
any generated event. named mousePressed(),
mouseClicked(), and
Listener mouseReleased() that are
Methods similar to the keyboard event
methods keyPressed(),
ActionListener keyTyped(), and
keyReleased().
actionPerformed(ActionEv
ent) The MouseInputListener
interface implements all the
AdjustmentListener
methods in both the
MouseListener and
adjustmentValueChanged(
AdjustmentEvent) MouseMotionListener
interfaces.
FocusListener
focusGained(FocusEvent)
and
focusLost(FocusEvent)
ItemListener
itemStateChanged(ItemEve
nt)
AWTEvent Class Methods
 Support for drag and drop This creates a JLabel
instance with the specified
Double buffering
text and horizontal
Key bindings alignment.

JComponent Class • JComponent class JLabel Methods

and its subclasses
• All Swing
components except
top-level containers
whose names begin
with “J” descend from
the JComponent
class (e.g., JPanel,
JScrollPane, and
JButton). JTextComponent Class
JLabel Class
• Inheritance Hierarchy The JTextComponent class
of the Jcomponent A JLabel object can display provides a base class for
class. either text or an image, or Swing components that
both. It cannot react to input handle editable text.
events but is instead
It provides the functionalities
commonly used to provide a
for entering and editing text
label identifier for a nearby
information—nearly all the
object that does.
features of a text editor.
The Jcomponent class The JLabel class uses three
JTextComponent has three
provides the following constants to align the
direct subclasses—
functionality to its component horizontally.
JTextField, JTextArea, and
descendants:
JLabel.LEFT JEditorPane.
Tool tips
JLabel.RIGHT • JTextField provides a
Painting and borders component for
JLabel.CENTER entering and editing a
Application-wide pluggable
One form of the constructor single line of text.
look and feel
for JLabel is: A constructor for JTextField
Custom properties
JLabel(String text, int where the parameter
Support for layout horizontalAlignment); specifies how many
characters wide the field is.
Support for accessibility
-JTextField(int numChars);
Another constructor for
JTextField is:
-JTextField(String text);
This constructs a new
TextField initialized with the
specified text.
JTextField Class
provides a component for
entering and editing a single
line of text.
A constructor for JTextField
where the parameter
specifies how many
characters wide the field is.
-JTextField(int numChars);
Another constructor for
JTextField is:
-JTextField(String text);
This constructs a new
TextField initialized with the
specified text.
JTextField Methods
JTextArea Class
A JTextArea object displays
multiple lines of text in a
single font and style and
optionally allows the user to
edit the text.
JTextArea Methods
JTextArea does not handle
scrolling, but implements the
swing Scrollable interface.
• JTextArea uses the
rows and columns
properties to indicate
the preferred size of
the viewport when
placed inside a
JScrollPane to match
JList Class
the functionality
provided by JList class is used to display
java.awt.TextArea. a list of items, such as list of
students, a list of files, and
Constructors used for
so forth.
JTextArea
• A JList object is
JTextArea(int rows, int constructed in a
columns) creates a new manner similar to the
empty TextArea with the
way a JComboBox
specified number of rows
object is constructed,
and columns.
that is, by passing an
JTextArea(String text) array of String.
creates a new TextArea with
String[] names = {″Mark″,
the specified text displayed.
″Antonio″, ″Lea″,
JTextArea(String text, int ″Sheila″};
rows, int columns) creates
JList list = new
a new TextArea with the
JList(names);
specified text and number of
rows and columns. JList three selection modes:
• single-selection
• single-interval
• multiple-
interval.
Statements show how to set
the three selection modes:
list.setSelectionMode(List
SelectionModel.
SINGLE_SELECTION);
list.setSelectionMode(List
SelectionModel.
SINGLE_INTERVAL_SELE
CTION);
list.setSelectionMode(List
SelectionModel.
MULTIPLE_INTERVAL_SE
LECTION);
JList Methods
JComboBox Class
The JComboBox is a
component that combines
two features:
• display area showing
an option, and
• a list box containing
additional options.
You can build a
JComboBox by using a
constructor with no
arguments and then adding
items (e.g., Strings) to the list
with the addItem() method.
ComboBox fruitChoice =
new JComboBox();
fruitChoice.addItem(″Apple
″);
fruitChoice.addItem(″Bana
na″);
fruitChoice.addItem(″Cherr
y″);
Alternatively, you can
construct a JComboBox
using an array of Objects as
the constructor argument.
The Objects in the array
become the listed items
within the JComboBox.
String[] fruitArray =
{″Apple, Banana, Cherry″};
JComboBox fruitChoice =
new
JComboBox(fruitArray);
ComboBox Method
AbstractButton Class
AbstractButton is an
abstract base class of button
and menu objects (e.g.,
JButton, JToggleButton,
JCheckBox, JRadioButton,
and JMenuItem).
It defines much of the
functionality for all button
types.
Methods defined here are
applicable to all subclasses.
JButtons act as push
buttons which invoke some
action when clicked. These
are not buttons that are
toggled on and off.
To construct a JButton
object, use the new
keyword. Then add the
button to the frame’s content
pane. The add() method of a
content pane puts a JButton
in the frame.
The getContentPane()
method of a frame is used to
get the reference to the
content pane.

JToggleButton Class
JToggleButton is an
extension of AbstractButton
and is used to represent
buttons that can be toggled
on and off (as opposed to
buttons like JButton which,
when pushed, "pop back
up").
JToggleButton has two
direct subclasses—
• JCheckBox
and
JRadioButton.
JCheckBoxes Class
• The JCheckBox is
typically used to allow
the user to turn an
option on or off.
Creates four JCheckBox
objects – one with no label
and unselected, two with
labels and unselected, and
one with a label and
selected.
If you do not initialize a
JCheckBox with a label and
you want to assign one later,
or if you want to change an
existing label, you can use
the setText() method as in
box1.setText(″Check this
box!″);
• The state of a
JCheckBox can be
changed with the
setSelected()
method.
box1.setSelected(false);
• The isSelected()
method is used to
check if a checkbox
button is selected
(i.e., has a check
mark) or deselected.
When the status of a
JCheckBox changes from
unchecked to checked or
vise versa, an ItemEvent is
generated and the
itemStateChanged()
method is executed.
You can use the getItem()
method to determine which
object generated the event
and the getStateChange()
method to determine
whether the event was a
selection or a deselection.
The getStateChange()
method returns an integer
that is equal to one of two
class variables –
ItemEvent.SELECTED or
ItemEvent.DESELECTED.
ActionListener listener = new
ActionListener() {
public void
actionPerformed(ActionEv
ent event) {
int mode = 0;
if (bold.isSelected())
mode += Font.BOLD;
if (italic.isSelected())
mode += Font.ITALIC;
label.setFont(new
Font("Serif", mode,
FONTSIZE));
}
};
JRadio Button Class
The JRadioButton class is
used to represent a type of
button called a radio button.
Like the checkbox button,
you can select or deselect a
radio button.
But unlike with a checkbox
button, you can only select
one of the radio buttons that
belong to the same group.
Like JCheckBox,
JRadioButton generates
both action events and item
events.
Constructors of the
JRadioButton:
JRadioButton(Icon icon,
boolean selected) creates a
radio button with the
specified image and
selection state, but no text.
JRadioButton(String text)
creates an unselected radio
button instance with the
specified text.
JRadioButton(String text,
boolean selected) creates a
radio button with the
specified text and selection
state.
JRadioButton(String text,
Icon icon) creates a radio
button that has the specified
text and image, and that is
initially unselected.
JRadio Button Methods
JScrollPane Class
The JScrollPane container
can hold components that
require more display area
than they have been
allocated.
The JScrollPane constructor
takes one of four forms:
-JScrollPane() creates an
empty JScrollPane in which
both horizontal and vertical
scroll bars appear when
needed.
-JScrollPane(Component)
creates a JScrollPane that
displays the contents of the
specified component.
-JScrollPane(Component,
int, int) creates a
JScrollPane that displays the
specified component and
includes both vertical and
horizontal scroll bar
specification.
-JScrollPane(int, int)
creates a JScrollPane with
both vertical and horizontal
scroll bar specifications.
If you want to force the
display of a scroll bar, you
can use class variables
defined in the
ScrollPaneConstants class.
ScrollPaneConstants.HORI
ZONTAL_
SCROLLBAR_AS_NEEDED
ScrollPaneConstants.HORI
ZONTAL_
SCROLLBAR_ALWAYS
ScrollPaneConstants.HORI
ZONTAL_
SCROLLBAR_NEVER
ScrollPaneConstants.VER
TICAL_
SCROLLBAR_AS_NEEDED
ScrollPaneConstants.VER
TICAL_
SCROLLBAR_ALWAYS
ScrollPaneConstants.VER
TICAL_
SCROLLBAR_NEVER
Creates a scroll pane
displaying an image named
picture, a vertical scroll bar,
and no horizontal scroll bar.
JScrollPane scroll = new
JScrollPane(picture,
ScrollPaneConstants.VER
TICAL_SCROLLBAR_
ALWAYS,
ScrollPaneConstants.HORI
ZONTAL_SCROLLBA
R_NEVER);
JScrollPane Method
Layout Managers
• A layout manager is
an object that controls
the placement (size
and position or layout)
of components inside
a Container object.
• Layout managers are
interface classes that
are part of the Java
SDK. These align
your components so
they neither crowd
each other nor
overlap.
• Each layout manager
defines
methods
that arrange
components within a
Container.
BorderLayout Managers
• A layout manager is
an object that controls
the placement (size
and position or layout)
of components inside
a Container object.
• Layout managers are
interface classes that
are part of the Java
SDK. These align
your components so
they neither crowd
 each other nor BorderLayout Managers FlowLayout Managers
overlap.
//content pane The FlowLayout manager
• Each layout manager class provides a simple
getContentPane().setLayo
defines layout manager that is used,
ut(new BorderLayout());
methods by default, by the JPanel
that arrange getContentPane().add(gen objects.
components within a derPanel,
It sizes each component
Container. BorderLayout.WEST);
according to its preferred
• BorderLayout divides getContentPane().add(heig size and arranges them in
a rectangular screen htPanel, horizontal wrapping lines so
area into five BorderLayout.EAST); that they are evenly spaced.
regions—a central
getContentPane().add(resu The advantages of the
region surrounded by
ltPanel, FlowLayout manager
four border regions.
BorderLayout.SOUTH); include its ease of use, and
• The following class the guarantee that each
constants are the • When you add a component can be seen.
predefined names that component to a
container that uses The FlowLayout class
identify the
BorderLayout, the contains three constants that
corresponding regions
add() method uses are used to align
(by common
two arguments: Components with a
convention, North is
Container.
assumed to be at the • the component the
top): region to which the FlowLayout.LEFT
• BorderLayout. component is added
FlowLayout.CENTER
NORTH contentPane.setLayout(ne
FlowLayout.RIGHT
• BorderLayout. w BorderLayout());
SOUTH
• BorderLayout. |
EAST |
• BorderLayout. V
WEST
• BorderLayout.
CENTER