MIDLANDS STATE UNIVERSITY

FACULTY OF SCIENCE AND TECHNOLOGY

DEPARTMENT OF INFORMATION SYSTEMS AND COMPUTER SCIENCE

NAME SURNAME REG NO MODE OF ENTRY

Tanaka Mapaike R165564M CON

Bright Kabasa R169884T CON

Chiedza V Chiwaridzo R164924R CON

Brenda Chaka R163360F CON

Nyasha Mupezeni R167210v CON

Panashe Mutsvangwa R167292Z CON

Prince Mataruse R166242V CON

Benedict Tapfuma R143890T CON

Lawrence Nyajambwa R163425R CON

Isheanesu Makwara R169276Q CON

What is an Event?

Change in the state of an object is known as event i.e. event describes the change in state of
source. Events are generated as result of user interaction with the graphical user interface
components. For example, clicking on a button, moving the mouse, entering a character through
keyboard, selecting an item from list, scrolling the page are the activities that causes an event to
happen.

Types of Events

The events can be broadly classified into two categories:

Foreground Events

- Those events which require the direct interaction of user. They are generated as consequences
of a person interacting with the graphical components in Graphical User Interface. For example,
clicking on a button, moving the mouse, entering a character through keyboard, selecting an item
from list, scrolling the page etc.

Background Events

- Those events that require the interaction of end user are known as background events.
Operating system interrupts, hardware or software failure, timer expires, an operation completion
are the example of background events.

What is Event Handling?

Event Handling is the mechanism that controls the event and decides what should happen if an
event occurs. This mechanism have the code which is known as event handler that is executed
when an event occurs. Java Uses the Delegation Event Model to handle the events. This model
defines the standard mechanism to generate and handle the events.

The Delegation Event Model has the following key participants namely:

Source - The source is an object on which event occurs. Source is responsible for providing
information of the occurred event to it's handler.
Listener - It is also known as event handler. Listener is responsible for generating response to an
event. From java implementation point of view the listener is also an object. Listener waits until
it receives an event. Once the event is received, the listener process the event an then returns.

The benefit of this approach is that the user interface logic is completely separated from the logic
that generates the event. The user interface element is able to delegate the processing of an event
to the separate piece of code. In this model, Listener needs to be registered with the source object
so that the listener can receive the event notification. This is an efficient way of handling the
event because the event notifications are sent only to those listeners that want to receive them.

Points to remember in event handling

 The User clicks the button and the event is generated.

 Now the object of concerned event class is created automatically and information about
the source and the event get populated with in same object.
 Event object is forwarded to the method of registered listener class. the method is now
get executed and returns.

Points to remember about listener

 In order to design a listener class we have to develop some listener interfaces.

 These Listener interfaces forecast some public abstract callback methods which must be
implemented by the listener class
 If you do not implement the any if the predefined interfaces, then your class can not act
as a listener class for a source object.

Event Handling Steps to follow

Following steps are required to perform event handling:

1. Register the component with the Listener
Registration Methods

For registering the component with the Listener , many classes provide the registration methods.
For example:

Button

public void addActionListener(ActionListener a){}

Menu Item

public void addActionListener(ActionListener a){}

Text Field

public void addActionListener(ActionListener a){}

public void addTextListener(TextListener a){}

TextArea

public void addTextListener(TextListener a){}

Checkbox

public void addItemListener(ItemListener a){}

Choice

public void addItemListener(ItemListener a){}

List

public void addActionListener(ActionListener a){}

public void addItemListener(ItemListener a){}

Java Event Handling Code

We can put the event handling code into one of the following places:

1. Within class
2. Other class

3. Anonymous class

Example

1.Java handling method within class

Java event handling by implementing ActionListener

import java.awt.*;

import java.awt.event.*;

class AEvent extends Frame implements ActionListener{

TextField tftough;

AEvent(){

//create components

tftough =new TextField();

tftough.setBounds(60,50,170,20);

Button but=new Button("press");

butsetBounds(100,120,60,20);

//register listener

but.addActionListener(this);

//passing current instance

//add components and set size, layout and visibility

add(but);add(tftough);

setSize(300,300);

setLayout(null);

setVisible(true); }
public void actionPerformed(ActionEvent e){

tftough.setText("COVID 19 will go soon");

} public static void main(String args[]){

new AEvent(); } }

2) Java event handling by outer class

import java.awt.*;

import java.awt.event.*;

class Eve2 extends Frame{

TextField tftough;

Eve2(){

//create components

tftough =new TextField();

tftough.setBounds(60,50,170,20);

Button b=new Button("cpress");

b.setBounds(100,120,60,20);

//register listener
Outer oouter=new Outer(this);
b.addActionListener(oouter);//passing outer class instance

//add components and set size, layout and visibility

add(b);

add(tftough);

setSize(300,300); setLayout(null); setVisible(true); }

public static void main(String args[]){ new Eve2(); } }

import java.awt.event.*;

class Outer implements ActionListener{

Eve2 object;

Outer(Eve2 object){

this.object=object; }

public void actionPerformed(ActionEvent e)

{ object.tftough.setText("Keep Social Distance");

}}

3) Java event handling by anonymous class

import java.awt.*;

import java.awt.event.*;

class Event3 extends Frame{

TextField tfen;

Event3(){

tfen=new TextField();

tfen.setBounds(60,50,170,20);

Button b=new Button("press");

b.setBounds(50,120,80,30);

b.addActionListener(new ActionListener(){

public void actionPerformed(){

tfen.setText("sanitize");

} });
add(b);add(tf); setSize(300,300); setLayout(null); setVisible(true); }

public static void main(String args[]){ new Event3(); } }

Interfaces

Event and Listener (Java Event Handling)

Changing the state of an object is known as an event. For example, click on button, dragging
mouse etc. The java.awt.event package provides many event classes and Listener interfaces for
event handling.

Important Event Classes and Interface

Event Classes Description Listener Interface

ActionEvent generated when button is pressed, menu-item is ActionListener

selected, list-item is double clicked

MouseEvent generated when mouse is dragged, MouseListener

moved,clicked,pressed or released and also when it
enters or exit a component

KeyEvent generated when input is received from keyboard KeyListener

ItemEvent generated when check-box or list item is clicked ItemListener

TextEvent generated when value of textarea or textfield is TextListener

changed
MouseWheelEve generated when mouse wheel is moved MouseWheelListener
nt

WindowEvent generated when window is activated, deactivated, WindowListener

deiconified, iconified, opened or closed

ComponentEvent generated when component is hidden, moved, resized ComponentEventListener

or set visible

ContainerEvent generated when component is added or removed from ContainerListener

container

AdjustmentEvent generated when scroll bar is manipulated AdjustmentListener

FocusEvent generated when component gains or loses keyboard FocusListener

focus