Object Oriented Programming. Interface Event Handling.
-
Upload
oliver-horton -
Category
Documents
-
view
255 -
download
0
Transcript of Object Oriented Programming. Interface Event Handling.
Interface Event Handling
Using interface, we specify what a class must do, but not how it does this.
An interface is syntactically similar to a class, but it lacks instance variables and its methods are declared without any body.
An interface is defined with an interface keyword.
Two types of access:◦ public – interface may be used anywhere in a program◦ default – interface may be used in the current package only
Interface methods have no bodies – they end with the semicolon after the parameter list. They are essentially abstract methods.
An interface may include variables, but they must be final, static and initialized with a constant value.
In a public interface, all members are implicitly public.
A class implements an interface if it provides a complete set of methods defined by this interface.◦ any number of classes may implement an interface◦ one class may implement any number of interfaces
Each class is free to determine the details of its implementation.
Implementation relation is written with the implements keyword.
Declaration of the Callback interface:
Client class implements the Callback interface:
An event is an action initiated by the user interacting with the program.
Examples◦ Keyboard events - pressing a key, holding a key, releasing a key◦ Mouse events - moving the mouse, clicking the mouse◦ GUI events - clicking on a button, resizing a window, closing a window,
opening a window An event in Java is an object of a particular event class, that
represents some user actions to which the GUI might respond
Low level events represent direct communication from the user Low level event examples (all the event classes listed below belong
to the java.awt.event package0:◦ key event - a keyboard key pressed or released - in the KeyEvent class◦ focus event – a component got focus, lost focus – in the FocusEvent class◦ mouse event - the mouse is moved or dragged, a mouse button is pressed or
released, the mouse cursor enters or exits a component - in the MouseEvent class
◦ component event - a component is hidden, shown, resized, or moved – in the ComponentEvent class
◦ container event - a component is added to or removed from a container in the ContainerEvent class
◦ window event - a window is opened, closed, activated, deactivated, etc. - in the WindowEvent class
High level events usually involve one or more low level events
High Level Event examples◦ action event - do a command – ActionEvent class◦ adjustment event - represents scrollbar motions such as a value
was adjusted – AdjustmentEvent class◦ item event - occurs when the user selects a checkbox, choice, or
list item, i.e. item state has changed –ItemEvent class◦ text event – represents a text component content (value) change –
TextEvent class
When the user clicks the mouse on a button, then releases it, the button gets two or three separate, low level mouse events◦ one for mouse down ◦ one for mouse up◦ possibly one for mouse drag (if the user moves the mouse
while the button is pressed) However, the button then fires one high level event
only - ActionEvent
Events are organized into hierarchy of event classes Event classes contain data relevant to a particular
event type An event is an object of one of the event classes
java.util.EventObject
java.awt.AWTEvent
AdjustmentEvent ComponentEventActionEvent TextEventItemEvent
WindowEventInputEventFocusEventContainerEvent
MouseEventKeyEvent
PaintEvent
java.lang.Object
The type of an event depends on its source Example of event sources:◦ the keyboard◦ the mouse◦ the GUI components – buttons, text fields, windows
Event source is an object with the ability to determine when an event has occurred
In event driven programming the events “drive” the execution of the program, e.g. the code is executed when events are activated
The program interacts with the user and generates events based on the external user actions
Java Visual (Graphical) programming and Visual Basic programming are event driven
When writing applets that are using events in Java we have to import the “events” package java.awt.event.*;
Java uses delegation-based model for event handling
Java uses event listener to register an event and event handler to respond to the event
The use of event listeners in event handling is called delegation event model
An external user’s action on a source object (e.g. the event source) activates an event
An event listener object (e.g. an object interested in the event source) receives the event. This object is an instance of a class that implements a specific EventListener interface ◦ Example: ActionEvent --> ActionListener
The source maintains a list containing all the listener objects that have registered to be notified of events of that type
The transmission of an event from an event source to an event listener involves invoking a method on the listener object by which the source notifies the listener of the occurrence of an event of a specific type ◦ Example: method actionPerformed (ActionEvent e)◦ An EventListener interface declares one or more methods
which must be defined in the listener class, and which are invoked by the event source in response to each specific event type handled by the interface Example:
EventListener method actionPerformed (ActionEvent e)
The Java standard class library contains several classes that represent typical events
Components, such as an applet or a button, generate (fire) an event when it occurs
Objects, called listeners, wait for events to occur. A listener object is an instance of a class that implements a specific listener interface
A number of listener interfaces are pre-defined and each interface declares the appropriate methods for a specific class of events
Component
This object maygenerate an event
Listener
This object waits for andresponds to an event
Event
When an event occurs, the component callsthe appropriate method of the listener,
passing an (event) object that describes the event
Each event is represented by an object that gives information about the event and identifies the event source.
Each event source can have multiple listeners registered on it. A single listener can register with multiple event sources.
event source
event listener 1
event listener 2
event listener 3
A listener object can be registered on a source object to be notified of the occurrence of all events of the specific class for which the listener object is designed
The occurrence of an event defined by the specified class will automatically invoke the matching method in the listener object
The code in the body of the method is designed by the programmer to perform the desired action when the event occurs
We can create a listener object by writing a class that implements a particular listener interface
The Java standard class library contains several interfaces that correspond to particular event categories
After creating the listener, we add the listener to the component that might generate the event to set up a relationship between the component, generating the event and the event listener
Register an event listener◦ “listens” for events generated by GUI components
◦an object of a class from the package java.awt.event Implement an event handler◦ a method that is automatically called in response to a particular
type of event
For each event class there is a corresponding listener interface defined in Java and corresponding listener methods (handlers) in the listener interface
Example : ◦ for the event class ActionEvent ◦ the listener is ActionListener ◦ and the listener method (handler) is actionPerformed (ActionEvent e )
Commonly used AWT event Listeners◦ActionListener◦AdjustmentListener◦ FocusListener◦ ItemListener◦KeyListener◦MouseListener◦MouseMotionListener◦MouseWheelListener◦WindowListener◦WindowFocusListener◦WindowStateListener
Every event handler requires three separate steps1. In the declaration for the event handler class, we specify that the
class either implements a listener interface or extends a class that implements a listener interface
public class MyClass implements ActionListener { … }
2. Code that registers an instance of the event handler class as a listener upon one or more components
someComponent.addActionListener(instanceOfMyClass);
3. Code that implements the methods in the listener interfacepublic void actionPerformed(ActionEvent e) { //code that reacts to the action... }
Adapter Class exists as convenience for creating a listener object. Extend this class to create a listener for a particular listener
interface and override the methods for the events of interest. It defines null methods for all of the methods in the listener
interface, so you can only have to define methods for events you care about.
Commonly used adapter classes:◦ FocusAdapter◦ KeyAdapter◦ MouseAdapter◦ MouseMotionAdapter◦ WindowAdapter