Events and Event Listeners in Java

Updated August 2021 for Swing

Here is how Java processes events:

• A Component (like a JButton) must generate an event, that is, an object that is a subclass of AWTEvent
• You must create an Event Listener that can respond when the event occurs. The event listener is specific to the type of event. The event listener is the part of the program which does whatever you want to have happen when the JButton is pressed or the mouse is clicked, etc.
• You have to add the event listener to the component that generates the events. Each Component has a set of built in methods that add the various types of eventlisteners to that object: typically addXXXListener() method, where XXX is the event type you can listen for, for example addActionListener(). You can also remove listeners using the removeXXXListener() methods.
• In order to be an event handler you have to implement the interface for the listener type, otherwise, you cannot be added, ActionListener being one such type.

I. Low-level Events

Low-level events represent a low-level input or window operation, like a key press, mouse movement, or window opening. The following table displays the different low-level events, and the operations that generate each event (each operation corresponds to a method of the listener interface):

// Keyboard code for the pressed key.
int key = e.getKeyCode(); 
if (key == KeyEvent.VK_LEFT) { 
// left-arrow key;

For instance, typing the letter 'A' on the keyboard generates three events, one for pressing, one for releasing, and one for typing. Depending upon your interests, you can do something for any of the three events.

II. Semantic Events

Semantic events represent interaction with a GUI component; for instance selecting a button, or changing the text of a text field. Which components generate which events is shown in the next section.The semantic events are generated by the following

e.g. Object target = e.getSource(); 
          // which component produced this event?
         if (target instanceof Button)
         System.out.print("Button was clicked.");
 

e.g.   if (e.getStateChange() == ItemEvent.SELECTED) {

Event Sources and Listeners (this tells you which listener to use for which event)

The following table show the different event sources.

• Keep in mind the object hierarchy. For instance, when Component is an event source for something, so are all its subclasses.
• Notice that although there is only one MouseEvent class, the listeners are spread across two interfaces. This is for performance issues. Since motion mouse events are generated more frequently, if you have no interest in them, you can ignore them more easily, without the performance hit.
• Each listener interface is paired with one event type and contains a method for each type of event the event class embodies. For instance, the KeyListener contains three methods, one for each type of event that the KeyEvent has: keyPressed(), keyReleased(), and keyTyped().

Summary of Listener interfaces and their methods

Event Adapters

Since the low-level event listeners have multiple methods to implement, there are event adapter classes to ease the pain. Instead of implementing the interface and stubbing out the methods you do not care about, you can subclass the appropriate adapter class and just override the one or two methods you are interested in. If listeners only contain one method to implement, there is no need for adapter classes.

Event Listeners
+ can be used if extending other classes
- you need to add ALL methods even if you don't use them

public class MyKeystroke extends ABCDE implements KeyListener {

  @Override
  public void keyPressed(KeyEvent e) {
    System.out.println("User typed: " +
      KeyEvent.getKeyText(e.getKeyCode()));
  }

  @Override
  public void keyReleased(KeyEvent e) {}		//required, but does nothing

  //NOTE: keyPressed() reacts much faster than keyTyped() so use it
  @Override
  public void keyTyped(KeyEvent e) {}			//required, but does nothing
}

Event Adapters
+ you only need one method
- you cannot extend any other superclass

public class MyKeyAdapter extends KeyAdapter {		//same as above, but with a KeyAdapter instead

  @Override
  public void keyTyped(KeyEvent e) {
    System.out.println("User typed: " +
      KeyEvent.getKeyText(e.getKeyCode()));
  }
}

Events Generated by Swing Components

Table: http://docs.oracle.com/javase/tutorial/uiswing/events/eventsandcomponents.html
and https://docs.oracle.com/javase/tutorial/uiswing/events/api.html

Old stuff:

  public void windowClosing(WindowEvent e) {
    setVisible(false);
    dispose();
    System.exit(0);
  }
  public void windowClosed(WindowEvent e) {}
  public void windowDeactivated(WindowEvent e) {}
  public void windowActivated(WindowEvent e) {}
  public void windowDeiconified(WindowEvent e) {}
  public void windowIconified(WindowEvent e) {}
  public void windowOpened(WindowEvent e) {}
}