Graphical User Interface in
Java
Graphical User Interface
In Java, GUI-based programs are
implemented by using classes from the
javax.swing and java.awt packages.
The Swing classes provide greater
compatibility across different operating
systems. They are fully implemented in
Java, and behave the same on different
operating systems.
AWT and Swing
Swing is the part of JFC (Java Foundation
Classes) built on the top of AWT and
written entirely in Java. The javax.swing
API provides all the component classes like
JButton, JTextField, JCheckbox, JMenu,
etc.
AWT and Swing
Abstract Windows Toolkit (AWT) and
Swing are used to develop window-based
applications in Java.
Awt is an abstract window toolkit that
provides various component classes like
Label, Button, TextField, etc., to show
window components on the screen. All these
classes are part of the Java.awt package.
AWT and Swing
The components of Swing are platform-
independent, i.e., swing doesn't depend on the
operating system to show the components.
Also, the Swing's components are lightweight.
The main differences
between AWT and Swing are given in the
following table.
AWT and Swing
AWT and Swing
Java Swing Hierarchy
AWT Event Class Hierarchy
Sample GUI Objects
Various GUI objects from the javax.swing
package.
Subclassing JFrame
To create a customized frame window,
we define a subclass of the JFrame
class.
The JFrame class contains rudimentary
functionalities to support features found
in any frame window.
Creating a Subclass of JFrame
To define a subclass of another class, we declare
the subclass with the reserved word extends.
import javax.swing.*;
class MyJFrame extends JFrame {
. . .
}
Example
Code
import javax.swing.*;
Import GUI swing
package
public class JFrameSubclass extends JFrame {
private static final int FRAME_WIDTH=300;
private static final int FRAME_HEIGHT=200;
private static final int FRAME_X_ORIGIN=150;
private static final int FRAME_Y_ORIGIN = 250;
public JFrameSubclass () {
setTitle("My First Subclass");
setSize(FRAME_WIDTH, FRAME_HEIGHT);
setLocation(FRAME_X_ORIGIN, FRAME_Y_ORIGIN);
setDefaultCloseOperation(EXIT_ON_CLOSE);
}
}
Code
import javax.swing.*; Create a subclass that
inherits JFrame class
public class JFrameSubclass extends JFrame {
private static final int FRAME_WIDTH=300;
private static final int FRAME_HEIGHT=200;
private static final int FRAME_X_ORIGIN=150;
private static final int FRAME_Y_ORIGIN = 250;
public JFrameSubclass () {
setTitle("My First Subclass");
setSize(FRAME_WIDTH, FRAME_HEIGHT);
setLocation(FRAME_X_ORIGIN, FRAME_Y_ORIGIN);
setDefaultCloseOperation(EXIT_ON_CLOSE);
}
}
Code
Constant declarations
import javax.swing.*;
public class JFrameSubclass extends JFrame {
private static final int FRAME_WIDTH=300;
private static final int FRAME_HEIGHT=200;
private static final int FRAME_X_ORIGIN=150;
private static final int FRAME_Y_ORIGIN = 250;
public JFrameSubclass () {
setTitle("My First Subclass");
setSize(FRAME_WIDTH, FRAME_HEIGHT);
setLocation(FRAME_X_ORIGIN, FRAME_Y_ORIGIN);
setDefaultCloseOperation(EXIT_ON_CLOSE);
}
}
Code
Constructor for this
import javax.swing.*; JFrameSubclass class
public class JFrameSubclass extends JFrame {
private static final int FRAME_WIDTH=300;
private static final int FRAME_HEIGHT=200;
private static final int FRAME_X_ORIGIN=150;
private static final int FRAME_Y_ORIGIN = 250;
public JFrameSubclass () {
setTitle("My First Subclass");
setSize(FRAME_WIDTH, FRAME_HEIGHT);
setLocation(FRAME_X_ORIGIN,
FRAME_Y_ORIGIN);
setDefaultCloseOperation(EXIT_ON_CLOSE);
}
}
Using methods from JFrame
class
setTitle methods:
setTitle
public void setTitle(String title)
Sets the title for this frame to the specified string.
Example:
setTitle("My First Subclass”);
Using methods in JFrame
setSize(int, int)
public void setSize(int width, int height)
Resizes this component so that it has width and
height.
Example:
setSize(FRAME_WIDTH,
FRAME_HEIGHT);
Using methods in JFrame
setLocation
public void setLocation(int x, int y)
Moves this component to a new location. The top-left
corner of the new location is specified by the x and y
parameters in the coordinate space of this
component's parent.
Example: setLocation(FRAME_X_ORIGIN,
FRAME_Y_ORIGIN);
Using methods in JFrame
setDefaultCloseOperation:
public void setDefaultCloseOperation(operation)
Example:
setDefaultCloseOperation(EXIT_ON_CLOSE);
Using public constants in
JFrame
EXIT_ON_CLOSE
public static final int EXIT_ON_CLOSE
The Content Pane of a Frame
The content pane is where we put GUI objects such as
buttons, labels, scroll bars, and others.
We access the content pane by calling the frame’s
getContentPane method.
This
Thisgray
grayarea
areaisisthe
the
content pane of this
content pane of this
frame.
frame.
Changing the Background Color
Here's how we can change the background
color of a content pane to blue:
Container contentPane = getContentPane();
contentPane.setBackground(Color.BLUE);
Adding event-handling
Example
Create a button
Create a dumb GUI first
Add a module to handle event later
Create a dumb GUI
Code
import javax.swing.*;
import java.awt.*; Packages included for
event and GUI objects
import java.awt.event.*;
public class JButtonFrame extends JFrame {
private static final int FRAME_WIDTH=300;
private static final int FRAME_HEIGHT=200;
private static final int FRAME_X_ORIGIN=150;
private static final int FRAME_Y_ORIGIN = 250;
private static final int BUTTON_WIDTH=80;
private static final int BUTTON_HEIGHT=30;
private JButton cancelButton;
private JButton okButton;
Code
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class JButtonFrame extends JFrame {
private static final int FRAME_WIDTH=300;
private static final int FRAME_HEIGHT=200;
private static final int FRAME_X_ORIGIN=150;
private static final int FRAME_Y_ORIGIN = 250;
private static final int BUTTON_WIDTH=80;
private static final int BUTTON_HEIGHT=30;
private JButton cancelButton;
private JButton okButton;
Code
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class JButtonFrame extends JFrame {
private static final int FRAME_WIDTH=300;
private static final int FRAME_HEIGHT=200;
private static final int FRAME_X_ORIGIN=150;
private static final int FRAME_Y_ORIGIN = 250;
private static final int BUTTON_WIDTH=80;
private static final int BUTTON_HEIGHT=30;
private JButton cancelButton;
private JButton okButton;
Code
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class JButtonFrame extends JFrame {
private static final int FRAME_WIDTH=300;
private static final int FRAME_HEIGHT=200;
private static final int FRAME_X_ORIGIN=150;
private static final int FRAME_Y_ORIGIN = 250;
private static final int BUTTON_WIDTH=80;
private static final int BUTTON_HEIGHT=30;
private JButton cancelButton;
private JButton okButton;
Constructor for this class
public JButtonFrame () {
Container contentPane= getContentPane();
setTitle("My Button class");
setResizable(false);
setSize(FRAME_WIDTH, FRAME_HEIGHT);
setLocation(FRAME_X_ORIGIN, FRAME_Y_ORIGIN);
contentPane.setLayout(null);
contentPane.setBackground(Color.white);
Constructor (continue)
okButton = new JButton("OK");
okButton.setBounds(70,125,BUTTON_WIDTH,BUTTON_HEIGHT);
contentPane.add(okButton);
cancelButton = new JButton("Cancel");
cancelButton.setBounds(160,125,BUTTON_WIDTH,BUTTON_HEIG
HT);
contentPane.add(cancelButton);
}
}
Event Handling
An action involving a GUI object, such as clicking a
button, is called an event.
The mechanism to process events is called event
handling.
The event-handling model of Java is based on the
concept known as the delegation-based event model.
With this model, event handling is implemented by
two types of objects:
event source objects
event listener objects
Steps Required to Set Up Event
Handling for a GUI Component
Several coding steps are required for an
application to respond to events
Create a class for the event handler
Implement an appropriate event-listener
interface
Register the event handler
Event Source Objects
An event source is a GUI object where an event
occurs. We say an event source generates events.
Buttons, text boxes, list boxes, and menus are
common event sources in GUI-based applications.
Although possible, we do not, under normal
circumstances, define our own event sources when
writing GUI-based applications.
Event Listener Objects
An event listener object is an object
that includes a method that gets
executed in response to the generated
events.
A listener must be associated, or
registered, to a source, so it can be
notified when the source generates
events.
Connecting Source and
Listener
event source event listener
notify
JButton Handler
register
A listener must be registered to a event source. Once
registered, it will get notified when the event source
generates events.
Event Types
Registration and notification are specific to event types
Mouse listener handles mouse events
Item listener handles item selection events
and so forth
Among the different types of events, the action event is
the most common.
Clicking on a button generates an action event
Selecting a menu item generates an action event
and so forth
Action events are generated by action event sources and
handled by action event listeners.
Handling Action Events
action event action event
actionPerformed
source listener
JButton Button
Handler
addActionListener
JButton button = new JButton("OK");
ButtonHandler handler = new ButtonHandler( );
button.addActionListener(handler);
Review
A Java interface is different from a class
because it includes only
to specify the behavior and does not
include data members or
B. Implementation
A. Method declarations
of a method
Review
A Java interface is different from a class
because it includes only A
to specify the behavior and does not
include data members or B
B. Implementation
A. Method declarations
of a method
Code for event-handling
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class ButtonHandler implements ActionListener {
public ButtonHandler() { }
public void actionPerformed(ActionEvent event){
JButton clickedButton=(JButton) event.getSource();
JRootPane rootPane = clickedButton.getRootPane();
JFrame frame =(JFrame) rootPane.getParent();
String buttonText = clickedButton.getText();
frame.setTitle("You clicked "+buttonText+" button");
}
}
Add code to JButtonFrame
class
….
ButtonHandler handler = new
ButtonHandler();
cancelButton.addActionListener(handler);
okButton.addActionListener(handler);
setDefaultCloseOperation(EXIT_ON_CLOSE);
}
}
Main class
public class JButtonFrameMain {
public static void main(String[] args) {
JButtonFrame frameObj = new
JButtonFrame();
frameObj.setVisible(true);
}
}
Practice (in class)
Practice (GUI) (in class)
Create a frame that contains 3 buttons:
1st semester
Summer
2nd semester
Whenever a user click on each button, the title
of the frame that changes to “ This is 1st
semester”, “This is summer” and “This is 2nd
semester”
Adding label and text field
Label
Textfield
Code – GUI handler
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class GuiHandler implements ActionListener {
public GuiHandler() { }
public void actionPerformed(ActionEvent event){
if (event.getSource() instanceof JButton) {
JButton clickedButton=(JButton) event.getSource();
JRootPane rootPane = clickedButton.getRootPane();
JFrame frame =(JFrame) rootPane.getParent();
String buttonText = clickedButton.getText();
frame.setTitle("You clicked "+buttonText+" button");
}
else if (event.getSource() instanceof JTextField) {
JTextField inputTextField=(JTextField) event.getSource();
JRootPane rootPane = inputTextField.getRootPane();
JFrame frame =(JFrame) rootPane.getParent();
String inputText = inputTextField.getText();
frame.setTitle("You entered "+inputText);
}
}
}
Code - TextFrame
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class JTextFrame extends JFrame {
private static final int FRAME_WIDTH=300;
private static final int FRAME_HEIGHT=200;
private static final int FRAME_X_ORIGIN=150;
private static final int FRAME_Y_ORIGIN = 250;
private static final int BUTTON_WIDTH=80;
private static final int BUTTON_HEIGHT=30;
private JButton cancelButton;
private JButton okButton;
private JLabel prompt;
private JTextField inputLine;
Code
public JTextFrame () {
Container contentPane= getContentPane();
setTitle("My Button class");
setResizable(false);
setSize(FRAME_WIDTH, FRAME_HEIGHT);
setLocation(FRAME_X_ORIGIN,
FRAME_Y_ORIGIN);
contentPane.setLayout(null);
contentPane.setBackground(Color.white);
GuiHandler handler = new GuiHandler();
Code
prompt = new JLabel();
prompt.setText("Please enter your name");
prompt.setBounds(85,20,150,25);
contentPane.add(prompt);
inputLine = new JTextField();
inputLine.setBounds(90,50,130,25);
contentPane.add(inputLine);
inputLine.addActionListener(handler);
Code
okButton = new JButton("OK");
okButton.setBounds(70,125,BUTTON_WIDTH,BUTTON_HEIGHT);
contentPane.add(okButton);
cancelButton = new JButton("Cancel");
cancelButton.setBounds(160,125,BUTTON_WIDTH,BUTTON_HEIGHT);
contentPane.add(cancelButton);
cancelButton.addActionListener(handler);
okButton.addActionListener(handler);
setDefaultCloseOperation(EXIT_ON_CLOSE);
}
}
The Java Interface
A Java interface includes only constants and abstract
methods.
An abstract method has only the method header, or
prototype. There is no method body. You cannot
create an instance of a Java interface.
A Java interface specifies a behavior.
A class implements an interface by providing the
method body to the abstract methods stated in the
interface.
Any class can implement the interface.
ActionListener Interface
When we call the addActionListener method of an event
source, we must pass an instance of a class that
implements the ActionListener interface.
The ActionListener interface includes one method named
actionPerformed.
A class that implements the ActionListener interface must
therefore provide the method body of actionPerformed.
Since actionPerformed is the method that will be called
when an action event is generated, this is the place
where we put a code we want to be executed in
response to the generated events.
Container as Event Listener
Instead of defining a separate event listener such as
ButtonHandler, it is much more common to have an object
that contains the event sources be a listener.
Example: We make this frame a listener of the
action events of the buttons it contains.
event listener
event source
GUI Classes for Handling Text
The Swing GUI classes JLabel, JTextField, and
JTextArea deal with text.
A JLabel object displays uneditable text (or image).
A JTextField object allows the user to enter a single
line of text.
A JTextArea object allows the user to enter multiple
lines of text. It can also be used for displaying
multiple lines of uneditable text.
JTextField
We use a JTextField object to accept a single line
to text from a user. An action event is generated
when the user presses the ENTER key.
The getText method of JTextField is used to
retrieve the text that the user entered.
JTextField input = new JTextField( );
input.addActionListener(eventListener);
contentPane.add(input);
JLabel
We use a JLabel object to display a
label.
A label can be a text or an image.
When
JLabel
creating an image label, we pass
textLabel = new JLabel("Please enter your name");
contentPane.add(textLabel);
ImageIcon object instead of a string.
JLabel imgLabel = new JLabel(new ImageIcon("cat.gif"));
contentPane.add(imgLabel);
JPasswordField
allows the editing of a single line of text
where the view indicates something was
typed, but does not show the original
characters.
JPasswordField passwordLine = new
JPasswordField();
passwordLine.setBounds(90,110,130,25);
contentPane.add(passwordLine);
Example – Let’s make this frame
JTextArea
We use a JTextArea object to display or allow the user to
enter multiple lines of text.
The setText method assigns the text to a JTextArea,
replacing the current content.
The append method appends the text to the current text.
JTextArea textArea
= new JTextArea( ); Hello
the lost world
. . .
textArea.setText("Hello\n");
textArea.append("the lost ");
textArea.append("world");
JTextArea
Let’s modify our example to add
this
Adding Scroll Bars to
JTextArea
By default a JTextArea does not have
any scroll bars. To add scroll bars, we
place a JTextArea in a JScrollPane
object.
JTextArea textArea = new JTextArea();
. . .
JScrollPane scrollText = new JScrollPane(textArea);
. . .
contentPane.add(scrollText);
TextArea with Scroll Bars
Placing GUI Objects on a Frame
There are two ways to put GUI objects on
the content pane of a frame:
Use a layout manager
FlowLayout
BorderLayout
GridLayout
Use absolute positioning
null layout manager
Layout Managers
The layout manager determines how the GUI
components are added to the container (such as the
content pane of a frame)
Among the many different layout managers, the
common ones are
FlowLayout
BorderLayout
GridLayout
FlowLayout
In using this layout, GUI component share placed in
left-to-right order.
When the component does not fit on the same
line, left-to-right placement continues on the next
line.
As a default, components on each line are centered.
When the frame containing the component is resized,
the placement of components is adjusted
accordingly.
FlowLayout Sample
This shows the
placement of five
buttons by using
FlowLayout.
BorderLayout
This layout manager divides the container into five
regions: center, north, south, east, and west.
The north and south regions expand or shrink in
height only
The east and west regions expand or shrink in width
only
The center region expands or shrinks on both height
and width.
Not all regions have to be occupied.
BorderLayout Sample
GridLayout
This layout manager placesGUI
components on equal-size N by M grids.
Components are placed in top-to-
bottom, left-to-right order.
The number of rows and columns
remains the same after the frame is
resized, but the width and height of
each region will change.
GridLayout Sample
Nesting Panels
It is possible, but very difficult, to place all
GUI components on a single JPanel or other
types of containers.
A better approach is to use multiple panels,
placing panels inside other panels.
JButton
Button
Component user clicks to trigger a specific
action
Can be command button, check box,
toggle button or radio button
Button types are subclasses of class
AbstractButton
JButton
JButtons can have a rollover icon
Appears when mouse is positioned over a
button
Added to a JButton with method
setRolloverIcon
Buttons That Maintain State
State buttons
Swing contains three types of state buttons
JToggleButton, JCheckBox and
JRadioButton
JCheckBox and JRadioButton are
subclasses of JToggleButton
JCheckBox
JCheckBox
Contains a check box label that appears to right of
check box by default
Generates an ItemEvent when it is clicked
ItemEvents are handled by an
ItemListener
Passed to method itemStateChanged
Method isSelected returns whether check box
is selected (true) or not (false)
JCheckBox
JCheckBox
JCheckBox boldJCheckBox;
JCheckBox italicJCheckBox;
boldJCheckBox = new JCheckBox( "Bold" );
italicJCheckBox = new JCheckBox( "Italic" );
JRadioButton
JRadioButton
Has two states – selected and unselected
Normally appear in a group in which only
one radio button can be selected at once
Group maintained by a ButtonGroup object
Declares method add to add a JRadioButton to
group
Usually represents mutually exclusive
options
JRadioButton
JRadioButton plainJRadioButton;
JRadioButton boldJRadioButton;
ButtonGroup radioGroup;
plainJRadioButton=new JRadioButton( "Plain", true );
boldJRadioButton=new JRadioButton( "Bold", false );
radioGroup = new ButtonGroup();
radioGroup.add( plainJRadioButton );
radioGroup.add( boldJRadioButton );
JComboBox and Using an
Anonymous Inner Class for Event
Handling
Combo box
Also called a drop-down list
Implemented by class JComboBox
Each item in the list has an index
setMaximumRowCount sets the maximum
number of rows shown at once
JComboBox provides a scrollbar and up
and down arrows to traverse list
JList
List
Displays a series of items from which the user
may select one or more items
Implemented by class JList
Allows for single-selection lists or multiple-
selection lists
A ListSelectionEvent occurs when an item
is selected
Handled by a ListSelectionListener and
passed to method valueChanged
Multiple-Selection Lists
Multiple-selection list
Enables users to select many items
Single interval selection allows only a
continuous range of items
Multiple interval selection allows any set of
elements to be selected
Menus
The javax.swing package contains three menu-
related classes: JMenuBar, JMenu, and JMenuItem.
JMenuBar is a bar where the menus are placed.
There is one menu bar per frame.
JMenu (such as File or Edit) is a group of menu
choices. JMenuBar may include many JMenu objects.
JMenuItem (such as Copy, Cut, or Paste) is an
individual menu choice in a JMenu object.
Only the JMenuItem objects generate events.
Menu Components
Edit View Help
JMenuBar File Edit View Help
JMenu
JMenuItem
separator
Sequence for Creating Menus
1. Create a JMenuBar object and attach it
to a frame.
2. Create a JMenu object.
3. Create JMenuItem objects and add
them to the JMenu object.
4. Attach the JMenu object to the
JMenuBar object.
Handling Mouse Events
Mouse events include such user interactions as
moving the mouse
dragging the mouse (moving the mouse while the
mouse button is being pressed)
clicking the mouse buttons.
The MouseListener interface handles mouse button
mouseClicked, mouseEntered, mouseExited,
mousePressed, and mouseReleased
The MouseMotionListener interface handles mouse
movement
mouseDragged and mouseMoved.
Multiple choices review -
Inheritance
If a variable is declared as protected, then
A. only the methods in the same class can access
the variable.
B. no method can change the value of the variable.
C. any method anywhere can change the value of
the variable.
D. any method within a subclass can access the
variable.
Multiple choices review -
Inheritance
If a variable is declared as protected, then
A. only the methods in the same class can access
the variable.
B. no method can change the value of the variable.
C. any method anywhere can change the value of
the variable.
D. any method within a subclass can access the
variable.
Inheritance overview
Which of the following is not a
superclass/subclass relationship?
a. Ford/Taurus.
b. University/Brown University.
c. Cat/Dog.
d. Country/USA.
Inheritance overview
Which of the following is not a
superclass/subclass relationship?
a. Ford/Taurus.
b. University/Brown University.
c. Cat/Dog.
d. Country/USA.
Inheritance overview
An advantage of inheritance is that:
a. All methods can be inherited.
b. All instance variables can be uniformly
accessed by subclasses and superclasses.
c. Objects of a subclass can be treated like
objects of their superclass.
d. None of the above.
Inheritance overview
An advantage of inheritance is that:
a. All methods can be inherited.
b. All instance variables can be uniformly
accessed by subclasses and superclasses.
c. Objects of a subclass can be treated like
objects of their superclass.
d. None of the above.
Inheritance overview
Superclass methods with this level of
access cannot be called from
subclasses.
a. private.
b. public.
c. protected.
d. package.
Inheritance overview
Superclass methods with this level of
access cannot be called from
subclasses.
a. private.
b. public.
c. protected.
d. package.
Inheritance
Which of the following is the superclass constructor
call syntax?
a. keyword super, followed by a set of parentheses.
b. keyword super, followed by a dot (.) .
c. keyword super, followed by a set of parentheses
containing the superclass constructor arguments.
d. keyword super, followed by a dot and the
superclass constructor name.
Inheritance
Which of the following is the superclass constructor
call syntax?
a. keyword super, followed by a set of parentheses.
b. keyword super, followed by a dot (.) .
c. keyword super, followed by a set of parentheses
containing the superclass constructor arguments.
d. keyword super, followed by a dot and the
superclass constructor name.
