Introduction To Event Handling In Java

Introduction

In this article, we discuss event handling (event and listener) in Java.

Event

An event happens when something changes within a graphical user interface.

We can say that events are objects in Java. It comes under some classes stored in java.util.EvenObject.

For example, events occur when a user clicks on a button, clicks on a combo box, or types characters into a text field, etcetera, such as in the following:

For a button, the event that is fired is the ActionListener.
For a text field, it's the KeyEvent.

The following figure clarifies events. When we click on the "click me" button an event is generated; that change event generates another frame that shows our message, that is passed to the program.

Listener class in Java

This class listens for the events in the application. It controls the application, without affecting its internal mechanism.

The Listener interfaces check the continuity of the work. The dispatching of a class must be able to rely on each of its listeners to contain the method that is executed, when the event occurs. It can be easily done in Java, by the use of an Interface class. The important point is that a class, which is going to be a listener, must implement that interface. They are:

ServletContextListener and
HttpSessionListener.

When a listener is created, by the property of the interface ",all the methods of that interface must be implemented". Some listeners, like the ActionListener, have only one method.

Event Handling in Java

The Abstract Window Toolkit (AWT) uses event driven programming to do processing of user actions, one that underlies all modern window systems programming. Within the AWT, all user actions belong to an abstract set of things called events. An event describes, in sufficient detail, a particular user action . Rather than, the program actively collecting user-generated events. The Java run time notifies the program when an interesting event occurs. Programs that handle user interaction in this fashion, are said to be event driven.

Event Handling

Event Handling provides four types of classes; they are:

Event Adapters
Event classes
Event Sources
Event Listeners

Event Adapters

In a program, when a listener has many abstract methods to override, it becomes complex for the programmer to override all of them.

For example, for closing a frame, we must override seven abstract methods of WindowListener, but we need only one method of them.

For reducing complexity, Java provides a class known as "adapters" or adapter class. Adapters are abstract classes, that are already being overriden.

Event classes

Every event source generates an event and is named by a Java class. An event is generated when something changes within a graphical user interface.

For example, the event generated by a:

Button is known as an ActionEvent
Checkbox is known as an ItemEvent

All of the events are listed in the java.awt.event package.

Event Sources

Event Sources are responsible for generating events and are called components.

The source for an event can be a button, TextField or a Frame etcetera.

Event Listeners

Events are handled by a special group of interfaces, known as "listeners".

How to perform event handling in Java

The following is required to perform event handling:

Implement the Listener interface and override its methods
Register the component with the listener

For adding various components, we use publics methods, for example:

Button
void addActionListener( ActionListener a)
List
void addActionListener(ActionListener a)
void addItemListener(ItemListener a)
Choice
void addItemListener(ItemListener x)
MenuItem
void addActionListener(ActionListener x)
TextField
void addActiontListener(ActionListener x)
void addTextListener(TextListener x)
TextArea
void addTextListener(TextListener x)
Checkbox
void addItemListener(ItemListener x)

We can use event handling in:

the same class
another class
anonymously

Event Handling within same class

The following is a sample of event handling, within the same class:

import java.awt.event.*;
import java.awt.*;
class EventActEx1 extends Frame implements ActionListener {
TextField txtfld;
EventActEx1() {
txtfld = new TextField();
txtfld.setBounds(65, 60, 190, 20);
Button bt = new Button("Click me");
bt.setBounds(100, 120, 80, 30);
bt.addActionListener(this);
add(bt);
add(txtfld);
setSize(350, 350);
setLayout(null);
setVisible(true);
}
public void actionPerformed(ActionEvent e) {
txtfld.setText("welcome 2 c-sharpcorner.com");
}
public static void main(String args[]) {
new EventActEx1();
}
}

Output

When we click on "click me" button, an event is generated that shows the "welcome 2 c-sharpcorner.com" message in the textfield area. Hence, we see an event change in this program.

Event Handling Example

The following is a sample of creating a frame that contains two buttons and one text field.

import java.awt.*;
import java.awt.event.*;
public class EventAction extends Frame implements ActionListener {
Label l;
public static void main(String argv[]) {
EventAction t = new EventAction();
}
public EventAction() {
super("Event generate in java");
setLayout(new BorderLayout());
try {
Button b = new Button("Enter your name in this block");
b.addActionListener(this);
add(b, BorderLayout.NORTH);
Button b1 = new Button("Write something about your self");
b1.addActionListener(this);
add(b1, BorderLayout.SOUTH);
l = new Label("c-sharpcorner.com");
add(l, BorderLayout.CENTER);
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent we) {
System.exit(0);
}
});
} catch (Exception e) {}
setSize(300, 300);
setVisible(true);
}
public void actionPerformed(ActionEvent e) {
Button bton = (Button) e.getSource();
String strng = bton.getLabel();
l.setText(strng);
}
}

Outputs

When we click on "Enter your name in this block" button an action is generated that provides a text field to write your name.

When we click on the "Write something about your self" button, an action is generated that provides an area to write something about yourself.