Title: Event-Driven Programming and Basic GUI Objects
1Chapter 7
- Event-Driven Programming and Basic GUI Objects
2Topics
- Graphical User Interfaces
- Inheritance
- GUI components
- Interfaces
- Events and Listeners
3Introduction
- This chapter covers the graphical user interface
(GUI). 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.
4GUI Components
- The javax.swing package contains a number of GUI
components. - JFrame
- JMenu
- JLabel
- JButton
- JTextField
- ImageIcon
- JTextArea
5Sample GUI Program
6Introduction
- AWT classes are implemented by using the native
GUI objects. - Swing classes support many new functionalities
not supported by AWT counterparts. - Do not mix the counterparts in the same program
because of their differences in implementation.
7Introduction
- To build an effective GUI using objects from the
Swing and AWT packages, we must learn a new style
of program control called event-driven
programming. - An event occurs when the user interacts with a
GUI object. - In event-driven programs, we program objects to
respond to these events by defining
event-handling methods.
8Creating a Subclass of JFrame
- As we know from Chapter 1, inheritance is a
feature we use to define a more specialized class
from an existing class. - The existing class is the superclass and the
specialized class is the subclass.
9Inheritance hierarchy of JOptionPane
- From the API documentation.
- java.lang.Object
- - java.awt.Component
- - java.awt.Container
- - javax.swing.JComponent
- - javax.swing.JOptionPane
10Creating a Subclass of JFrame
- To create a customized user interface, we often
define a subclass of the JFrame class. - The JFrame class contains rudimentary
functionalities to support features found in any
frame window.
11Default JFrame Window
- A default JFrame window appears at the top left
corner of the screen. - You may not notice this because it is so small.
- It looks different on computers running different
operating systems
12Creating a Subclass of JFrame
- To define a subclass of another class, we declare
the subclass with the reserved word extends. - class Ch7JFrameSubclass1 extends JFrame
- ...
-
13Creating a Subclass of JFrame
- We will also add the following default
characteristics - The title is set to My First Subclass.
- The program terminates when the close box is
clicked. - The size of the frame is 300 pixels wide by 200
pixels high. - The frame is positioned at screen coordinate
(150, 250). - These properties are set inside the default
constructor.
14Size and Location of a JFrame
- How an instance of Ch7JFrameSubclass1 will appear
on the screen.
15Inheritance
- Every method of a superclass is inherited by its
subclass. - Because the subclass-superclass relationships are
formed into an inheritance hierarchy, a subclass
inherits all methods defined in its ancestor
classes.
16Another Subclass of JFrame
- Next we will define another subclass called
Ch7JFrameSubclass2, which will have a white
background. - We will define this class as an instantiable main
class so we dont have to define a separate main
class.
17Using the Content Pane
- To make the background white, we must access the
frames content pane, the area of the frame
excluding the title and menu bars and the border. - We access the content pane by calling the frames
getContentPane method. We change the background
color by calling the content panes setBackground
method.
18Ch7JFrameSubclass2
19Using Buttons in a JFrame
- There are two approaches to placing GUI objects
on a frames content pane. - One approach uses a layout manager, an object
that controls the placement of the GUI objects. - The other approach uses absolute positioning to
explicitly specify the position and size of GUI
objects on the content pane.
20Absolute Positioning of Components
- To use absolute positioning, set the layout
manager of a frames content pane to none by
passing null to the setLayout method. - contentPane.setLayout(null)
- Set the size and position of a button by calling
the buttons setBounds method - okButton.setBounds( 75, 125, 80, 30)
- The first two arguments specify the buttons
position. - The last two arguments specify the width and
height of the button. - To make a button appear on the frame, add it to
the content pane by calling the add method. - contentPane.add(okButton)
21Button Placement
22Handling Button Events
- 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.
23Event Handling in Java
24Event Sources and Listeners
- An event source object is a GUI object where an
event occurs. An event source generates events. - An event listener object is an object that
includes a method that gets executed in response
to the generated events. When an event is
generated, the system notifies the relevant event
listener objects.
25Events
- There are many different kinds of events, but the
most common one is an action event. - For the generated events to be processed, we must
associate, or register, event listeners to the
event sources. - If event sources have no registered listeners,
the events they generate are ignored.
26Listener Classes
- An object that can be registered as an action
listener must be an instance of a class that is
declared specifically for the purpose. We call
such classes action listener classes. - To associate an action listener to an action
event source, we call the event sources
addActionListener method with the action listener
as its argument.
27Listeners and Event Sources
- A single listener can be associated to multiple
event sources. - Likewise, multiple listeners can be associated to
a single event source.
28Event Handling
- When an event source generates an event, the
system checks for matching registered listeners. - If there is no matching listener, the event is
ignored. - If there is a matching listener, the system
notifies the listener by calling the appropriate
method in the listener. - In the case of action events, the method called
is actionPerformed. - How does the system know it can call this method
for any listener class?
29Interfaces
- Like a class, an interface is a reference data
type, but unlike a class, an interface includes
only constants and abstract methods. - An abstract method has only the method header, or
prototype it has no method body. - An interface cannot be instantiated.
- You use an interface by writing a class that
implements an interface.
30Implementing Interfaces
- A class that implements a Java interface must
provide the method body for all the abstract
methods defined in the interface. - By requiring an object we pass as an argument to
the addActionListener method to be an instance of
a class that implements the ActionListener
interface, the system ensures that this object
will include the necessary actionPerformed
method. - We use ActionListener as a parameter type in the
addActionListener method - An object from any class that implements
ActionListener can be used as an argument.
31ActionListener Classes
- ActionListener is an interface, not a class.
- To ensure that the programmer includes the
necessary actionPerformed method in an action
listener class, the class must implement the
ActionListener interface. - import java.awt.event.
- class ButtonHandler implements ActionListener
- ...
-
- In the actionPerformed method, we need to define
what should happen when an event occurs.
32The actionPerformed method
- To change the title of the frame, depending on
which button is clicked, we use the
actionPerformed method. The method model is - public void actionPerformed(ActionEvent evt)
- String buttonText
- get the text of the event source
- JFrame frame
- the frame that contains this event source
- frame.setTitle(You clicked buttonText)
33Finding the Source of an Event
- We can get the text from the event source using
the getActionCommand method of the action event
object evt - String buttonText
- evt.getActionCommand()
- We can get a reference to the event source itself
using the getSource method of the action event
object evt. - JButton clickedButton
- (JButton) evt.getSource()
- String buttonText clickedButton.getText()
- Note that the object returned by the getSource
method may be an instance of any Component class,
so we type cast the returned object to a proper
class in order to use the desired method.
34Identifying the Frame
- To find the frame that contains the event source,
we - get the root pane to which the event source
belongs, then - get the frame that contains this root pane.
- JRootPane rootPane clickedButton.getRootPane()
- Frame frame (JFrame) rootPane.getParent()
35Chapter7JButtonFrame
- A sample window when it is first opened and after
the CANCEL button is clicked.
36Frames as Listeners
- A frame window contains nested layers of panes.
- The topmost pane is called the root pane.
- The frame can be the event listener for the GUI
objects it contains. - cancelButton.addActionListener(this)
- okButton.addActionListener(this)
- The Frame can call its setTitle method directly.
- The frame class must implement ActionListener
37Classes for Text
- The Swing GUI classes JLabel, JTextField, and
JTextArea all deal with text. - A JLabel object displays uneditable (by the user)
text. - 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.
38JTextField Class
- An instance of JTextField generates action events
when the object is active and the user presses
the ENTER key. - The actionPerformed method must determine which
of the three event sources in our example (two
buttons and one text field) generated the event.
39What class does an Object Come From?
- The instanceof operator determines the class to
which the event source belongs. The general model
is thus - if (event.getSource() instanceof JButton )
- //event source is either cancelButton
- //or okButton
- ...
-
- else //event source must be inputLine
- ...
40JTextField
- The getText method of JTextField may be used to
retrieve the text that the user entered. - public void actionPerformed(ActionEvent event)
- if (event.getSource() instanceof JButton)
- JButton clickedButton
- (JButton) event.getSource()
- String buttonText clickedButton.getText()
- setTitle(You clicked buttonText)
- else //the event source is inputLine
- setTitle(You entered
- inputLine.getText() )
-
41JLabel
- A JLabel object is useful for displaying a label
indicating the purpose of another object, such as
a JTextField object. - prompt new JLabel(Please enter your name)
42Images in JLabel Objects
- JLabel objects may also be used to display
images. - They can display text, image or both
- To create a JLabel with an image instead of text,
we pass an ImageIcon object instead of a string. - To create the ImageIcon object, we must specify
the filename of the image.
43JLabel
- We declare the data member
- private JLabel image
- then create it in the constructor as
- public Ch7TextFrame2
- ...
- image new JLabel(new ImageIcon(cat.gif)
- //note that this assumes the .gif is
- //in the same directory as the program
- image.setBounds(10, 20, 50, 50)
- contentPane.add(image)
- ...
44Ch7TextFrame2
- A window with one text JLabel, one image JLabel,
one JTextField, and two JButton objects.
45JTextArea
- Next we will declare a JTextArea object
- private JTextArea textArea
- and add statements to create it
- textArea new JTextArea()
- textArea.setBounds(50, 5, 200, 135)
- textArea.setBorder(BorderFactory.createLineBorder(
Color.red)) - textArea.setEditable(false)
- contentPane.add(textArea)
46Putting Borders on Components
- by default the rectangle indicating the boundary
of the JTextArea object is not shown on the
screen. - We call the createLineBorder method of the
BorderFactory class, because - We disable editing of the text area in the
statement - textArea.setEditable(false)
47Modifying Text in a JTextArea
- The append method allows us to add text to the
text area without replacing old content. - Using the setText method of JTextArea will
replace old content with new content. - See Ch7TextFrame3
48Scroll Bars
- To add scroll bars to the JTextArea object, we
amend the earlier code as follows - textArea new JTextArea()
- textArea.setEditable(false)
- JScrollPane scrollText new JScrollPane(textArea)
- textArea.setBounds(50, 5, 200, 135)
- textArea.setBorder(BorderFactory.createLine
- Border(Color.red))
- contentPane.add(scrollText)
- See TextFrame4
49Menus
- The javax.swing package contains three useful
menu-related classes - JMenuBar is a bar where the menus are placed.
- JMenu (such as File or Edit) is a single item in
the MenuBar. - JMenuItem (such as Copy, Cut, or Paste) is an
individual menu choice in the Menu.
50Using Menus
- When a MenuItem is selected, it generates a menu
action event. - We process menu selections by registering an
action listener to menu items.
51How to Implement Menus
- Create a JMenuBar object and attach it to a
frame. - Create a JMenu object.
- Create JMenuItem objects and add them to the
JMenu object. - Attach the JMenu object to the JMenuBar object.
52Creating a Menu
- We create a fileMenu object as
- fileMenu new Menu(File)
- The argument to the Menu constructor is the name
of the menu. - Menu items appear from the top in the order in
which they were added to the menu.
53Creating MenuItems
- To create and add a menu item New to fileMenu, we
execute - item new JMenuItem(New)
- item.addActionListener(this)
- fileMenu.add(item)
- And to add a horizontal line as a separator
between menu items, we execute - fileMenu.addSeparator()
54Creating the Menu Bar
- We create a JMenuBar object
- JMenuBar menuBar new JMenuBar()
- Then call the frames setMenuBar method to attach
it to the frame - setMenuBar(menuBar)
- Then add the two JMenu objects to the menu bar.
- menuBar.add(fileMenu)
- menuBar.add(editMenu)