Understanding Delegation Event Model in Java: An Overview

Sienna Roberts 30 August 2023

Explore the intricacies of the Delegation Event Model in Java. This blog delves into the concept of events in Java and how the Delegation Event Model functions. Gain insights into implementing the Delegation Event Model in Java and learn how to build a straightforward GUI application using this powerful approach.

Home

Resources

Programming & DevOps

Understanding Delegation Event Model in Java: An Overview

Training Outcomes Within Your Budget!

We ensure quality, budget-alignment, and timely delivery by our expert instructors.

Share this Resource

Table of Contents

Related Courses

The Delegation Event Model in Java is an essential concept for building Event-driven applications and facilitating communication between GUI components and Events. Understanding this model is vital for developers to create responsive and interactive applications.

According to a survey by Stack Overflow, Java is popular with 40.2% of correspondents. Java’s ability to create interactive applications plays a huge part in its popularity. In this comprehensive blog, we will explain the Delegation Event Model in Java, exploring its details, working, and different implementations in programming and development.

Table of Contents

1) What are Events in Java?

2) How Delegation Event Model Works?

3) Implementing Delegation Event Model in Java

4) Building a simple GUI application

5) Conclusion

What are Events in Java?

Events are often considered to be the driving force behind a programming paradigm. They wield the power to activate specific actions when interactions with the user occur or system notifications emerge. This Event-driven approach empowers developers to create applications that respond seamlessly to user inputs, delivering a dynamic and engaging experience.

At the core of Java's Event system lie two critical components, Event Sources and Event Listeners. The Event Sources, such as buttons or menus, serve as the origins of Events. They act as the catalysts that set the Event-Handling process in motion. On the other hand, Event Listeners play the role of vigilant observers, eagerly awaiting the Events triggered by the sources. When an Event emerges, these listeners leap into action, processing the Event and executing the appropriate response.

Learn more about coding in Java and its capabilities with our Java Training today!

How Delegation Event Model works?

The Delegation Event Model operates on a fascinating Event Delegation process in a Java program that sets it apart. When an Event occurs, it refrains from being directly handled by the Event Source. Instead, it adopts a delegatory approach by entrusting the task to the appropriate Event Listener. This unique mechanism ensures precise and efficient Event Handling, enhancing the overall responsiveness of Java applications.

To execute this process seamlessly, three key components stand tall. The Event Object serves as the encapsulator, containing essential details about the Event, such as its type and source. The Source refers to the GUI component responsible for generating the Event, while the Listener eagerly awaits to process and respond to the Event, adding dynamism to the application.

Flowchart of Delegation Event Model in Java

Another intriguing aspect of the Delegation Event Model lies in its Event propagation. The Event follows a captivating journey through two distinct phases. First, it embarks on the capturing phase, traversing from the root of the component hierarchy to the Event Source. Once the source is reached, the bubbling phase commences, with the Event traveling back to the root. This propagation mechanism allows multiple listeners to receive the Event, ensuring a harmonious interaction between Java applications and their users.

Master the multiplatform Java language with our Java Programming course today!

Implementing Delegation Event Model in Java

The Delegation Event Model offers loose coupling and code reusability, promoting maintainable applications. It enables flexibility and extensibility, allowing developers to add new Events effortlessly. To implement the Delegation Event Model in a Java program, follow these three steps:

Creating custom Events

To implement the Delegation Event Model, developers should first create custom Event classes that extend the ‘java.util.EventObject’ class. These custom Event classes act as containers for specific Event information and serve as a bridge between Event Sources and Listeners. For example, in a GUI application, developers can create a ‘CustomButtonClickEvent’ class to encapsulate data related to button click Events, such as the button's label, position, or any additional context-specific information.

Implementing Event Listeners

Next, developers need to implement Event Listener interfaces that are appropriate for the types of Events the application needs to handle. In Java, there are various Listener interfaces, such as ‘java.awt.event.ActionListener’, ‘java.awt.event.MouseListener’, and more.

Each interface contains specific methods that need to be implemented to respond to the corresponding Events. For instance, to handle button click Events, developers can create an ‘ActionButtonClickListener’ class that implements the ‘ActionListener’ interface and provides the necessary logic for processing button clicks.

Registering and Handling Events

Once the custom Event classes and Listener implementations are in place, developers can proceed with the registration and Event Handling process. To register Event listeners with their respective Event Sources, developers use methods like ‘addActionListener’ or ‘addMouseListener’. In our example, the ‘ActionButtonClickListener’ can be registered with a button using the ‘addActionListener’ (actionButtonClickListener) method.

When an Event, such as a button click, occurs, the Delegation Event Model takes over. The Event Source identifies the appropriate custom Event class (e.g., CustomButtonClickEvent) and populates it with relevant data about the Event. The source then delegates the Event to the registered listener (e.g., ActionButtonClickListener), passing the custom Event Object as a parameter.

Sample program to Handle Delegation Event Model in Java

Here is a sample Java Program to handle Delegation Event Model:

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

public class DelegationEventModelDemo {

public static void main(String[] args) {

// Step 1: Creating Custom Events

class CustomButtonClickEvent extends java.util.EventObject {

public CustomButtonClickEvent(Object source) {

super(source);

}

// Step 2: Implementing Event Listeners

class ActionButtonClickListener implements ActionListener {

public void actionPerformed(ActionEvent e) {

// Show a message dialog when the button is clicked

JOptionPane.showMessageDialog(null, "Button Clicked!");

}

// Step 3: Registering and Handling Events

Frame frame = new Frame("Delegation Event Model Demo");

frame.setLayout(new FlowLayout());

Button button = new Button("Click Me!");

frame.add(button);

ActionButtonClickListener actionButtonClickListener = new ActionButtonClickListener();

button.addActionListener(actionButtonClickListener);

frame.setSize(300, 200);

frame.setVisible(true);

frame.addWindowListener(new WindowAdapter() {

public void windowClosing(WindowEvent e) {

System.exit(0);

}

});

}

This program will require you to set the display variable in order to generate a window. Setting an ‘X11’ display variable is typically done in a Unix-like environment, such as Linux or macOS, when you want to run graphical applications remotely or on a different machine. To set the ‘X11’ display variable, you need to specify the IP address or hostname of the machine that will display the graphical output. The environment variable that holds the ‘X11’ display information is called DISPLAY. To make sure the display variable is set, be sure to use the following command:

export DISPLAY=IP_ADDRESS:0

Replace ‘IP_ADDRESS’ with the IP address or hostname of the machine where you want to display the graphical output. The ‘:0’ at the end represents the display number, and in most cases, it is set to ‘0’. For example, if you want to display graphical applications on the machine with IP address ‘192.168.1.100’, you will run:

export DISPLAY=192.168.1.100:0

Learn to build powerful desktop applications with our Java Swing Development Training!

Building a simple GUI application

Let’s take a real-life implementation by creating a basic calculator application with arithmetic operations. We'll follow three key steps: designing the GUI, implementing Event Listeners, and Handling Events.

Designing the GUI

First, design the GUI with buttons for numbers and arithmetic operations. For instance, create buttons for digits 0 to 9 and buttons for addition, subtraction, multiplication, and division. Arrange them in a visually appealing layout to provide a user-friendly experience.

Implementing Event Listeners

Implement Event Listeners to respond to button clicks. Create an Event Listener class that implements the ‘ActionListener’ interface, which includes the ‘actionPerformed’ method. In this method, identify the button that was clicked using the Event Object and perform the corresponding arithmetic operation. For example, when the addition button is clicked, extract the values from the input fields and add them together.

Event Handling in the application

When the user interacts with the calculator buttons, the Delegation Event Model will take charge. The Event Source, such as the addition button, will delegate the button click Event to the appropriate Event Listener, in this case, the addition Event Listener. The addition Event Listener will then execute the ‘actionPerformed’ method, Handling the addition operation and displaying the result on the calculator's display.

Try our Introduction to Java EE Training Course today and learn advanced Java!

Sample program

Once all the steps are followed, the resulting program should look something like this:

import java.awt.*;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import javax.swing.*;

public class BasicCalculator {

// Global variables to store the calculator input and result

private static JTextField inputField;

private static double result = 0;

public static void main(String[] args) {

// Step 1: Designing the GUI Interface

createGUI();

// Step 2: Implementing Event Listeners

// Create and register event listeners for each button

addActionListenerToButtons();

// Step 3: Event Handling in the Application

// Event handling is done through the actionPerformed method of the event listener

// When a button is clicked, its event listener will execute the corresponding operation

}

private static void createGUI() {

// Create the frame

JFrame frame = new JFrame("Basic Calculator");

frame.setLayout(new BorderLayout());

// Create the input field and add it to the frame

inputField = new JTextField(20);

inputField.setHorizontalAlignment(JTextField.RIGHT);

frame.add(inputField, BorderLayout.NORTH);

// Create the panel to hold the buttons

JPanel buttonPanel = new JPanel(new GridLayout(4, 4, 5, 5));

// Create the buttons and add them to the button panel

String[] buttonLabels = { "7", "8", "9", "+", "4", "5", "6", "-", "1", "2", "3", "*", "0", ".", "=", "/" };

for (String label : buttonLabels) {

JButton button = new JButton(label);

buttonPanel.add(button);

}

// Add the button panel to the frame

frame.add(buttonPanel, BorderLayout.CENTER);

// Set up the frame

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

frame.setSize(300, 300);

frame.setVisible(true);

}

private static void addActionListenerToButtons() {

// Get all the buttons in the frame

Component[] components = Frame.getFrames()[0].getContentPane().getComponents();

for (Component component : components) {

if (component instanceof JButton) {

JButton button = (JButton) component;

button.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

String command = e.getActionCommand();

// Check if the button clicked is a digit or an operator

if (Character.isDigit(command.charAt(0)) || command.equals(".")) {

// Append the digit or decimal point to the input field

inputField.setText(inputField.getText() + command);

} else if (command.equals("=")) {

// Evaluate the expression and display the result

calculateResult();

} else {

// Store the current input as the first operand and the operator

result = Double.parseDouble(inputField.getText());

inputField.setText("");

inputField.setText(inputField.getText() + command);

}

});

}

private static void calculateResult() {

String expression = inputField.getText();

try {

// Evaluate the expression using the built-in JavaScript engine

result = (double) new ScriptEngineManager().getEngineByName("JavaScript").eval(expression);

inputField.setText(String.valueOf(result));

} catch (ScriptException ex) {

// Handle any errors in the expression

inputField.setText("Error");

}

Conclusion

The Delegation Event Model in Java offers a powerful mechanism for Handling Events in Graphical User Interfaces (GUIs). Delegating Event Handling to specific Listeners allows it to ensure responsiveness and modularity. Implementing this model enhances code reusability, scalability, and flexibility, making it an indispensable tool for building interactive and dynamic Java applications. Embracing this model empowers developers to create sophisticated and user-friendly applications with ease.

Try our course in Web Development Using Java Training and learn about JSP today!