Features

Various events may happen to a running program: a user clicks on a button in a window, the Web browser decides to re-paint the window, and so on. I'm sure, you've tried to click on the buttons of the calculator from the lesson on Swing Basics, but these buttons were not ready to respond to your actions yet. This time, let's teach window components to react on such actions.

Each window component can listen to and process a number of events, and your program has to register window components with Java classes called listeners. You should make components listen to only those events they are interested in. For example, when a person moves the mouse cursor over the calculator button, it's not important where exactly the mouse pointer at the click-moment as long as it was right above the button. That's why you do not need to register the button with Java's MouseMotionListener. On the other hand, this listener is handy for all kinds of drawing programs.

Calculator's buttons should register themselves with the ActionListener that can process button-click events. All these listeners are special Java structures called interfaces.

Interfaces

Most of the GUI-related classes define methods that perform various actions, for example react to button clicks, react to mouse movements, and so on. A combination of such actions/reactions is called a class behavior.

Interfaces are special Java constructs that just declare a set of particular actions without containing an actual code that implements these actions, for example:

interface MouseMotionListener {
    void mouseDragged(MouseEvent e);
    void mouseMoved(MouseEvent e);
}

As you can see, the methods mouseDragged() and mouseMoved() do not have any code - they are just declared in the interface called MouseMotionListener. But if your class needs to react when the mouse is being moved or dragged, such class has to implement this interface. The word implements means that this class will definitely include the methods that might have been declared in this interface (I've used the word might, because some interfaces may not declare any methods), for example:

import java.awt.event.MouseMotionListener;

class myDrawingPad implements MouseMotionListener{

	// your code that can draw goes here

	mouseDragged(MouseEvent e){
	// your code that has to be performed when 
	// the mouse is being dragged goes here
	}
	mouseMoved(MouseEvent e){
	// your code that has to be performed when 
	// the mouse is being moved goes here
	}
}

You may be wondering, why even bother creating interfaces without writing the code in its methods? The reason is that once the interface is created, it could be reused by many classes. For example, when other classes (or JVM itself) see that the class myDrawingPad implements the interface MouseMotionListener, they know for sure that this class will definitely have methods mouseDragged() and mouseMoved(). Every time when a user moves the mouse, JVM will call the method mouseMoved()and execute the code that you wrote in the class that implements this interface. Imagine if a programmer Joe decides to name such a method mouseMoved(), Mary calls it movedMouse(), and Pete prefers mouseCrawling()? In this case the JVM would be confused and wouldn't know which method to call on your class to signal about the mouse movement.

A Java class can implement multiple interfaces, for example it may need to respond to mouse movements as well as to a button click:

class myDrawingProgram implements 
    MouseMotionListener, ActionListener {

   //You have to write the code for each method that 
   // has been defined in both interfaces here

}

The actionListener will take care of the button clicks, while the MouseMothionListener will deal with the mouse movements.

After getting comfortable with the interfaces that come with Java, you'll be able to create your own interfaces, and you can read more about it in my article "Are you Using Abstract Classes and Interfaces" http://java.sys-con.com/read/37695.htm.

Action Listener

Let's get back to our calculator from the Swing Basics lesson. Modify the class Calculator.java to add the buttons +, -, /, and *. Add these buttons to the panel p2, and place the panel in the East area of the content pane.

Now we'll create another class-listener that will react when the user clicks on one of the buttons. Actually, we could have added the code processing click events to the class Calculator.java itself, but it's better to keep visual and processing parts (the business logic) in separate classes.

We'll name a second class CalculatorEngine, and it must implement a java.awt.ActionListener interface that declares only one method - actionPerformed(ActionEvent). JVM calls this method on the class that implements this interface whenever the user clicks on the button. Create the following simple class:

import java.awt.event.ActionListener;
public class CalculatorEngine implements ActionListener {

}