Introduction to Web Programming
- In the JDK 1.0 event model discussion, we
described how you could subclass an object and implement handleEvent()
to catch events. We also explained how events were propagated up to
superclasses and also up the component chain from children to their
- The listener event model is a bit different.
Instead of events automatically posting to components, their parents,
and their superclasses, you must explicitly request an event to
- So, events aren't posted to all sorts of
methods that determine if they want to handle them. Instead they are
only posted to interested parties.
- In the listener event model, an object that
wants to listen for events explicitly notifies the object that
generates them that it's interested in receiving those events. The
object will add the listener to a list of listeners and inform the
listener group whenever an event occurs.
Becoming a Listener
Oh, by the way, the listener interfaces and
event classes are contained in the java.awt.event package. Thus
to use these classes you should import the event package like
- Thus, if you want to be a listener of buttons
you must implement the ActionListener interface that requires that
you implement a single method, actionPerformed().
- Here is a more complete example of creating a
dialog that listens for action events from a push button. Notice that
the MyDialog class implements the ActionListener interface and, as
such, defines the actionPerformed() method:
class MyDialog extends Dialog
private Button _okButton;
public void MyDialog()
... initialization code ...
_okButton = new Button("OK");
... more initialization code ...
public void actionPerformed(ActionEvent event)
if (event.getSource() == _okButton)
System.out.println("OK button was pressed");
- One benefit of the listener model is that it
allows an outsider to look at a component and by looking at its
methods, know what events it posts.
- For example, if you look at the Component
class, you will find a number of methods to add and remove listeners
public void addFocusListener(FocusListener l);
public void addKeyListener(KeyListener l);
public void addMouseListener(MouseListener l);
public void removeFocusListener(FocusListener l);
public void removeKeyListener(KeyListener l);
public void removeMouseListener(MouseListener l);
- You can use these methods to listen for
focus, key, and mouse events from any component. To listen for one of
these events, add the object that you want to receive the event as a
listener and implement the interface corresponding to the given
- The JDK contains a large number of listener
interfaces that can be implemented to listen for different types of
events. Consider the following list of listener classes and the
interfaces they define.
||Methods you must Implement
Previous Page |