Writing event listeners
by: Anatoliy Malyarenko
Abstract
Contents of the lecture.
- Introduction to event listeners.
- General information about writing event listeners.
- Implementing listeners for commonly handling events.
Introduction to event listeners
Let's look at one of the simplest event handling examples possible. It's called Beeper,
and it features a button that beeps when you click it.
Here's the code that implements the event handling for the button:
| Code: |
public class Beeper ... implements ActionListener {
...
//where initialisation occurs:
button.addActionListener(this);
...
public void actionPerformed(ActionEvent e) {
...//Make a beep sound...
}
}
|
The Beeper class implements the ActionListener interface, which contains one
method: actionPerformed. Since Beeper implements ActionListener, a Beeper object
can register as a listener for the action events that buttons fire. Once the Beeper has been
registered using the addActionListener method, the Beeper's actionPerformed method is
called every time the button is clicked.
The event model, which you saw at its simplest in the preceding example, is quite
powerful and flexible. Any number of event listener objects can listen for all kinds of events
from any number of event source objects. For example, a program might create one listener
per event source. Or a program might have a single listener for all events from all sources. A
program can even have more than one listener for a single kind of event from a single event
source.
Each event is represented by an object that gives information about the event and
identifies the event source. Event sources are often components or models, but other kinds of
objects can also be event sources.
The following example demonstrates that event listeners can be registered on multiple
objects and that the same event can be sent to multiple listeners. The example contains
two event sources (JButton instances) and two event listeners. One of the event listeners
(an instance of a class called MultiListener) listens for events from both buttons. When
it receives an event, it adds the event's "action command" (which is set to the text on the
button's label) to the top text area. The second event listener (an instance of a class called
Eavesdropper) listens for events on only one of the buttons. When it receives an event, it
adds the action command to the bottom text area.
Here's the code that implements the event handling for the button:
| Code: |
public class MultiListener ... implements ActionListener {
...
//where initialization occurs:
button1.addActionListener(this);
button2.addActionListener(this);
button2.addActionListener(new Eavesdropper(bottomTextArea));
}
public void actionPerformed(ActionEvent e) {
topTextArea.append(e.getActionCommand() + newline);
}
}
class Eavesdropper implements ActionListener {
...
public void actionPerformed(ActionEvent e) {
myTextArea.append(e.getActionCommand() + newline);
}
}
|
In the above code,
both MultiListener and Eavesdropper implement the
ActionListener interface and register as action listeners using the JButton addActionListener
method. Both classes' implementations of the actionPerformed method are similar: they
simply add the event's action command to a text area.
to be continued
3401 bytes more | comments? |   | Score: 0
|
Previous
1060 Stories (530 Pages, 2 Per Page)
Next
RSS feed Java Forums
