Sie sind auf Seite 1von 14


BBA Semester III

Event Handling in Java

Avi Batra, Namit Garg, Sanchit Sukhija


1. 2. 3. 4. 5. Event Handling Adapters Types of Events Different Events Drawing Lines 3 6 7 13 24

Event Handling

Every time the user types a character or pushes a mouse button, an event occurs. Any object can be notified of the event. All it has to do is implement the appropriate interface and be registered as an event listener on the appropriate event source. Swing components can generate many kinds of events.

Each event is represented by an object that gives information about the event and identifies the event source. Event sources are typically components, but other kinds of objects can also be event sources. Each event source can have multiple listeners registered on it. Conversely, a single listener can register with multiple event sources.

You That




work is





someone an



doorbell event!

In life, you encounter events that force you to suspend other activities and respond to them immediately. In Java, events represent all activity that goes on between the user and the application. Javas Abstract Windowing Toolkit (AWT) communicates these actions to the programs using events. When the user interacts with a program let us say by clicking a command button, the system creates an event representing the action and delegates it to the event-handling code within the program. This code determines how to handle the event so the user gets the appropriate response.

Like people, processes cannot always foresee the consequences of their actions. Java divides the realm of the unpredictable into exceptions and events. As we have seen, exceptions happen synchronously with a process; it is the immediate consequence of some action, such as division by 0. An event happens asynchronously, often as a result of something the user does. The Java GUI is event driven; user actions initiate events. Events are sent to a Java program by the underlying windowing system. Information about event is stored in an instance of a subclass of EventObject. Most of the events we will see are AWTEvents. Here is the hierarchy of AWTEvents java.lang.Object java.util.EventObject java.awt.AWTEvent java.awt.event.ActionEvent java.awt.event.AdjustmentEvent java.awt.ItemEvent java.awt.ComponentEvent java.awt.ContainerEvent java.awt.FocusEvent Lecture 16 Object-Oriented Languages and Systems 2 java.awt.InputEvent

java.awt.KeyEvent java.awt.MouseEvent java.awt.PaintEvent java.awt.WindowEvent To get an event processed, the programmer must write code to do two things: register an event listener, and implement an event handler.

Adapters Some interfaces, e.g., WindowListener, have many methods: public void windowOpened(WindowEvent e) public void windowIconified (WindowEvent e) public void windowDeiconified (WindowEvent e) public void windowClosed (WindowEvent e) public void windowActivated (WindowEvent e) public void windowDeactivated (WindowEvent e) We could just implement all of these methods in a class like HelloWorldSwing. But, because this is tedious, the java.awt.event package defines adapters for most of the Listeners. Adapters are classes that implement all of the methods in their corresponding interfaces, with null bodies. If the programmer only wants to define a few methods of the interface, (s) he can extend an adapter class, and override a few of its methods. However, this usually means that an object can no longer serve as a handler for its own events.


Types of events Let us take a look at a few components and the events that they generate Button events A button generates a button event when a user clicks it with a mouse. Buttons are usually created with a one-parameter constructor. This parameter specifies the buttons label: JButton myButton = new JButton("OK");

An ActionListener receives events from the button.

When a button is pressed and released, the AWT sends an instance of ActionEvent to the button, by calling processEvent on the button. the buttons processEvent method calls processActionEvent. processActionEvent passes the action event on to any ActionListeners that have registered an interest in events from this button. It does this by calling the ActionListeners actionPerformed method.

Keyboard events

Pressing or releasing a key generates a keyboard event. The KeyListener interface recognizes three kinds of events: keyPressed(KeyEvent) is called when an action key is depressed. Action keys include arrow keys, function keys,

Home, End, Page Up, Page Down, Num Lock, Print Screen, Scroll Lock, Caps Lock, and Pause. keyTyped(KeyEvent) is called when any other key is depressed. keyReleased(KeyEvent) is called after any key is released that has generated either of the above two events.

Four methods are useful in figuring out which key has been typed: int getKeyCode() returns the integer key code associated with the key in this event (only for keyPressed events). char getKeyChar() returns the character associated with the key (if any). String getKeyText(int keyCode) returns a string describing the keyCode, such as PAUSE or F1. String getKeyModifiersText(int modifiers) returns a string describing the modifier key(s), such as Shift or Ctrl+Shift. (Sample program to show working of Keyboard events)

Item events Several of the Swing classes implement the interface ItemSelectable, which indicates that they contain a set of items from which zero or more items may be selected. Among these classes are JButton, JCheckBox, JRadioButton, and JComboBox. A checkbox is a box that may be selected or deselected.

Any number of check boxes in a group may be selected. Radio buttons are a set of buttons of which only one can be selected at the same time. Such a set of buttons are members of the same ButtonGroup. A combo box, sometimes called a drop-down list or dropbox, allows a user to select an item from the list. Choosing an item generates an ItemEvent. The ItemEvent class contains a method getItemSelectable() to get the ItemSelectable object that generated the item event. Whenever an items state changes, the itemStateChanged() of the ItemListener class is called.

Different Events:

Event Object: When the user interacts with the application by clicking a mouse button or pressing a key an event is generated. The Operating System traps this event and the data associated with it. For example, info about time at which the event occurred, the event types (like keypress or mouse click). This data is then passed on to the application to which the event belongs. In Java, events are represented by objects, which describe the events themselves. And Java has a number of classes that describe and handle different categories of events.

Event Source: An event source is the object that generated the event. Example if you click a button an Action Event Object is generated. The object of the Action Event class contains information about the event.

Event-Handler: Is a method that understands the event and processes it. The eventhandler method takes the Event object as a parameter. Java uses Event-Delegation Model: with JDK1.1 onwards; you can specify the objects that are to be notified when a specific event occurs. If the event is irrelevant, it is discarded. The four main components based on this model are Event classes, Event Listeners, Explicit event handling and Adapters. Let us take a closer look at them one by one.

Event Classes: The EventObject class is at the top of the event class hierarchy. It belongs to the java.util package. While most of the other event classes are present in java.awt.event package, the getSource() method of the EventObject class returns the object that initiated the event. The getId () method returns the nature of the event. For example, if a mouse event occurs, you can find out whether the event was click, a press, a move or release from the event object. AWT provides two conceptual types of events: Semantic and low-level events. Semantic events are defined at a higher-level to encapsulate the semantics of user interface components model. Now let us see what the various semantic event classes are and what they generate:

An ActionEvent object is generated when a component is activated An AdjustmentEvent Object is generated when scrollbars and other adjustment elements are used. A TextEvent object is generated when text of a component is modified. An ItemEvent is generated when an item from a list, a choice or checkbox is selected. Low-Level Events is one that represents a low-level input or windows-system occurrence on a visual component on the screen. The various low-level event classes and what they generate are as follows: A ContainerEvent Object is generated when component are added or removed from container. A ComponentEvent object is generated when a component is resized, moved etc. A FocusEvent object is generated when component receives focus for input. A KeyEvent object is generated when key on keyboard is pressed, released etc.

A WindowEvent object is generated when a window activity, like maximizing or close occurs. A MouseEvent object is generated when a mouse is used. A PaintEvent object is generated when component is painted. Event Listeners: An object delegates the task of handling an event to an event listener. When an event occurs, an event object of the appropriate type (as illustrated below) is created. This object is passed to a Listener. A listener must implement the interface that has the method for event handling. A component can have multiple listeners, and a listener can be removed using removeActionListener () method. Next question in your mind must be what is an interface? An Interface contains constant values and method declaration. The difference between classes and interface is that the methods in an interface are only declared and not implemented, that is, the methods do not have a body. What is the Need for interface? Are interfaces are used to define behavior protocols (standard behavior) that can be implemented by any class anywhere in the class hierarchy. The java.awt.event package contains definitions of all event classes and listener interface. The semantic listener interfaces define by AWT for the above mentioned semantic events are: ActionListener AjdustmentListener ItemListener TextListener The low-level event listeners are as follows: ComponentListener ContainerListener FocusListener


KeyListener MouseListener MouseMotionListener WindowsListener.

ActionEvent using the ActionListener interface: The following illustrates the usage of ActionEvent and ActionListener interface in a Classic Java Application (Example I). //Save the file with file and compile it using javac, //once complied errors free execute it. Import javax.swings.*; Import java.awt.event.*; Public class MyEvent extends JFrame { JButton b1; // Main Method Public static void main (String arg[]) { MyEvent event = new MyEvent(); } //Constructor for the event derived class Public MyEvent() { Super(Window Title: Event Handling); b1 = new Jbutton(Click Me); //place the button object on the window getContentPane().add(center,b1); //Register the listener for the button ButtonListener listen = new ButtonListener(); b1.addActionListener(listen); //display the window in a specific size

setVisible(true); setSize(200,200); } //The Listener Class Class ButtonListener implements ActionListener { //Definition for ActionPerformed() method Public void ActionPerformed(ActionEvent evt) { JButton source = (JButton)evt.getSource(); Source.setText(Button Has Been Clicked, Guru!); } } } How An The Object does execution of the of the begins MyEvent the class above with is Application the created in class main the main is work? method. method. invoked.



Super () method calls the constructor of the base class and sets the title of the window as given. The The A button A addActionListener() SetVisible Application () waits object is created Listener method registers method for the and placed at the center is listener displays user to object for the of the window. created. button. window. with it.

Object the

the interact

When the user clicks on the button labeled Click Me: The ActionEvent event is generated. Then the ActionEvent object is created and delegated to the registered listener object for processing. The Listener object contains the actionPerformed() method which processes the ActionEvent In the actionPerformed() method, the reference to the event source is retrieved using getSource() method. The label of the button is changed to Button has been clicked, Guru! using setText() method.*

public class ClickListener extends Mouse Adapter { Public void Mouse Pressed(MouseEvent event) { System.out.println(Mouse pressed at ( +event.getX() + , + event.getY() + ).); } }

What happens when the user pushes the mouse

The scribbling starts at the point the mouse was

button? (mouseDown) What happens when the user lets go of the mouse button? (mouseUp) What happens when the mouse is just moving over the applet? (mouseMove) What happens when the mouse is dragged over the applet? (mouseDrag) What happens when the mouse enters the applet's space? (mouseEnter) What happens when the mouse leaves the applet's space? (mouseExit) pushed The scribbling stops Nothing There is a line drawn behind the mouse Nothing Nothing

What is the difference between MouseClicked and MouseReleased? Among other things, each MouseEvent object contains the x and y coordinates where the event occurred. These values can be retrieved via the int getX() and int getY() methods of the mouse event. On some systems, mice have more than one button. MouseEvent inherits methods from InputEvent to allow it to distinguish among the buttons. isMetaDown() returns true when the user clicks the right button on a mouse with two or three buttons. How do you think this might be simulated on a one-button mouse? isAltDown() returns true when the user clicks the middle button on a three-button mouse.

Drawing Lines The question now becomes: How do you draw lines on the screen? Here's a brief explanation.

The screen is represented by a special Java object called a Graphics object. You have to have a Graphics object before you can draw on anything. Graphics objects have many methods built-in, for drawing all sorts of shapes and patterns. In this exercise, there is only one method we are interested in: drawLine(). drawLine() requires 4 pieces of information to function properly: it needs to know the x coordinate and the y coordinate where the line

should begin, and the x coordinate and the y coordinate where the line should stop. So to draw a line from (10,10) to (50,55), you would use the line:

g.drawLine(10, 10, 50, 55);

NOTE: this will only work, of course, if g is a Graphics object.

So, in our mouseDrag() method, we need to do the following:

We need to get the graphics object that represents the screen, and we need to draw a line on that object, from the last point the mouse was at to the point it's at now. In addition to all this, applets have a special method that is used to go find the Graphics object that represents the screen. That method is getGraphics().

Bring it all together, and your code should look like this:

public boolean mouseDrag(Event e, int x, int y) { Graphics g = getGraphics(); g.drawLine(xpoint, ypoint, x, y); }