What is Event Handling in Java? & Why use Event Handlers?

Event Handling in Java

A key idea in Java’s Graphical User Interface (GUI) development is event management, which allows programs to react to user input and other events produced by the system. The contemporary method for managing these occurrences is the Delegation Event Model, which establishes uniform and standardised processes for their creation and handling.

The Delegation Event Model

The Delegation Event Model is based on the straightforward idea that an event creates an event object and then forwards it to one or more event listeners. After patiently awaiting an event, the listener processes it and then relinquishes control. A major benefit of this architecture is that it allows a user interface element to “delegate” event processing to a separate piece of code by clearly separating the application logic (what occurs in response to an event) from the user interface logic (how the event is generated).

This strategy, which is more effective than previous approaches, requires listeners to register with a order to receive notifications for particular kinds of events. This ensures that notifications are only provided to those who are interested.

Event Sources

An object that starts an event when its internal state changes is known as an event source. Various kinds of events can be produced by sources. The must register the listener in order for them to get notifications regarding a specific event type. Usually, methods with the general form public void addTypeListener(TypeListener el) are used for this registration, where ‘Type’ denotes the name of the event and ‘el’ denotes the event listener. Event sources include, for example:

Buttons: When pressed, they cause action events.
Text fields/areas: Produce text events (when a value changes) and action events (when Enter).
Check boxes/Lists: Produce action events (double-click for lists) or item events (selection/deselection).
Mouse: Produces mouse events (wheel moved, dragged, clicked, pressed, released, entered, and exited).
Keyboard: Produces key events (typed, pressed, and released).
Windows: Produce window events, such as iconification, closure, and activation.

Additionally, unregister listener methods, such as public void removeTypeListener(TypeListener el).

Event Objects

A data structure that contains details on a state change is called an event object. These items can be created by actions such as clicking the mouse, inputting a character, or pressing a button.

The base of Java’s event class hierarchy is the class EventObject, which may be found in java.util. The superclass for all AWT-based events managed by the delegation model is AWTEvent (in java.awt), which is a subclass of EventObject. Important functions are getID(), which determines the event type, and getSource(), which retrieves the object that caused the event.

The following are typical event classes found in java.awt.event:

ActionEvent: For selecting menu items, double-clicking lists, and pressing buttons.
MouseEvent: For mouse operations (wheel rotations, clicks, drags, presses, and releases).
ItemEvent: For selecting or deselecting items from a list or tick box.
KeyEvent: For typing, releasing, and pressing keys on a keyboard.
WindowEvent: For modifications to the status of a window (active, closed, opened, etc.).

Event Listeners

An object that receives notifications when an event takes place is known as an event listener. Two essential conditions must be met for a listener to operate properly:

To get notifications for particular event categories, it needs to be registered.
It needs to have procedures in place to get and handle these alerts.

The java.awt.event package has a collection of listener interfaces that define these event processing techniques.

Implementing Listener Interfaces

There are two primary steps in using the Delegation Event Model:

To obtain the required event type, implement the relevant interface in the listener.
Put code in place to register the listener with the event source (and unregister them if needed).

The following are instances of popular listener interfaces:

ActionListener: Defines the actionPerformed(ActionEvent ae) method, invoked when an action event (e.g., button press) occurs.
MouseListener: Defines five methods for various mouse events: mouseClicked(), mouseEntered(), mouseExited(), mousePressed(), and mouseReleased().
ItemListener: Defines the itemStateChanged(ItemEvent ie) method, invoked when an item’s state changes (e.g., a checkbox is selected/deselected).

Let’s illustrate with a simple JButton and an ActionListener.

import javax.swing.*;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.awt.FlowLayout; // For simple layout
public class ButtonClickDemo extends JFrame implements ActionListener {
    JLabel label;
    JButton button;
    ButtonClickDemo() {
        setTitle("Event Handling Demo");
        setSize(300, 150);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLayout(new FlowLayout());
        button = new JButton("Click Me!");
        // Register this class (ButtonClickDemo) as the listener for the button
        button.addActionListener(this); 
        label = new JLabel("Button not clicked yet.");
        add(button);
        add(label);
        setVisible(true);
    }
    @Override
    public void actionPerformed(ActionEvent ae) {
        // This method is called when the button is clicked
        label.setText("Button was clicked!");
    }
    public static void main(String[] args) {
        // GUI updates should happen on the Event Dispatch Thread
        SwingUtilities.invokeLater(ButtonClickDemo::new); 
    }
}

Code Output: Initially, the window shows “Click Me!” button and “Button not clicked yet.”. After clicking the button: “Button was clicked!” appears next to the button.

Anonymous Inner Classes for Event Handling

An instance of an anonymous inner class is created “on the fly” where it is required, rather than having a name explicitly assigned. Because they don’t require explicit references and have automatic access to the enclosing class’s instance variables and functions, they are especially helpful for event handling. This can greatly simplify programming that handles events.

Here’s how the previous example’s ActionListener could be implemented using an anonymous inner class:

import javax.swing.*;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.awt.FlowLayout;
public class AnonymousClassDemo extends JFrame {
    JLabel label;
    JButton button;
    AnonymousClassDemo() {
        setTitle("Anonymous Inner Class Demo");
        setSize(300, 150);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLayout(new FlowLayout());
        button = new JButton("Click Me!");
        // An anonymous inner class implements ActionListener directly here
        button.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent ae) {
                // 'label' is directly accessible from the enclosing class
                label.setText("Button was clicked using an anonymous class!");
            }
        });
        label = new JLabel("Button not clicked yet.");
        add(button);
        add(label);
        setVisible(true);
    }
    public static void main(String[] args) {
        SwingUtilities.invokeLater(AnonymousClassDemo::new);
    }
}

Code Output: Initially, the window shows “Click Me!” button and “Button not clicked yet.”. After clicking the button: “Button was clicked using an anonymous class!” appears.

Lambda Expressions for Event Handling

Lambda expressions, which were introduced in Java 8, provide an even more succinct method of implementing functional interfaces. Any interface that specifies a single abstract method is considered functional. One of the best examples of a functional interface is ActionListener, which has only one actionPerformed() method.

The arrow operator -> is used in lambda expressions to separate the lambda body from the parameter list. They offer a more condensed option to anonymous inner classes, particularly in cases when the event handling mechanism is straightforward.

Rewriting the ActionListener using a lambda expression:

import javax.swing.*;
import java.awt.FlowLayout;
public class LambdaDemo extends JFrame {
    JLabel label;
    JButton button;
    LambdaDemo() {
        setTitle("Lambda Expression Demo");
        setSize(350, 150);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLayout(new FlowLayout());
        button = new JButton("Click Me!");
        // Lambda expression directly implements the actionPerformed method
        button.addActionListener(ae -> {
            label.setText("Button was clicked using a lambda expression!");
        });
        label = new JLabel("Button not clicked yet.");
        add(button);
        add(label);
        setVisible(true);
    }
    public static void main(String[] args) {
        SwingUtilities.invokeLater(LambdaDemo::new);
    }
}

Code Output: Initially, the window shows “Click Me!” button and “Button not clicked yet.”. After clicking the button: “Button was clicked using a lambda expression!” appears.

Similar to anonymous inner classes, lambda expressions make event handling easier by implicitly capturing variables from their enclosing scope. This means that label.setText() operates without requiring the label reference to be passed explicitly. The intricacy of the handler and the particular requirements of the application will determine whether to use anonymous inner classes, the standard method, or lambda expressions; nonetheless, lambdas frequently offer the most concise solution for straightforward event processing.

Page Content

Tutorials