Java eLearning Kit For Dummies (2014)

Files needed: MyEventListener.java

1. Open the editor or IDE that you’ve chosen to use for this book.

2. Type the following code into the editor screen.

// Import the required API classes.
import java.util.EventListener;

// An event listener listens for an event to occur.
public interface MyEventListener extends EventListener
{
// When the event happens, the event listener tells
// everyone about it.
public void EventHappened(MyEvent Event);
}

Describing what an event listener interface does takes considerably longer than writing the event listener interface code. In this case, MyEventListener inherits from EventListener. It defines a single method, EventHappened(), that specifies a single method used to tell classes that an event has happened.

3. Using the standard commands of your editor or IDE, save this file as MyEventListener.java.

4. In your command prompt, type javac MyEventListener.java and press Enter.

The compiler compiles your application and creates a .class file from it.

Implementing the event as part of a class definition

At this point, you have an event and an event listener description. So, you have the resources for telling everyone that an event has occurred, but you have no mechanism to deliver or manage the event. An event class uses the event and the event interface, along with some management code, to make it possible to fire events (make them happen) and to manage a list of event handlers (classes that want to hear about the event and are listening for it).

In the following example, you create an interface that describes the interaction required between a class that defines an event and one that uses the event. The interface doesn’t provide an implementation; it merely describes what must happen.

Files needed: SampleEventClass.java

1. Open the editor or IDE that you’ve chosen to use for this book.

2. Type the following code into the editor screen.

// Import the required API classes.
import javax.swing.event.EventListenerList;

// An event class manages the event. It provides the
// means for adding and removing listeners and also
// firing the event when it happens.
public class SampleEventClass
{
// Create a variable to hold a list of listeners,
// which are applications that want to know 

// about the event.
protected EventListenerList ListenerList =
new EventListenerList();

// Add an event listener to the list.
public void AddEventListener(MyEventListener Listener)
{
ListenerList.add(MyEventListener.class, Listener);
}

// Remove an event listener from the list.
public void RemoveEventListener(MyEventListener Listener)
{
ListenerList.remove(MyEventListener.class, Listener);
}

// Fire the event, tell everyone that something has
// happened.
public void FireEvent(MyEvent Event)
{
// The event manager must tell each of the
// listeners in turn, so you need a list of 

// listeners.
Object[] Listeners = ListenerList.getListenerList();

// Process each of the event listeners in turn.
for (int i = 0; i < Listeners.length; i+=2)
{
// An event list could contain any number of
// events,so you need to ensure you
// process only the listeners that want to 

// hear about this particular event.
if (Listeners[i] == MyEventListener.class)
{
// Fire the EventHappened method using the
// event argument supplied by the caller.
((MyEventListener)Listeners[i+1]).EventHappened(Event);
}
}
}
}

More than one method can listen for events generated by your event class. As a result, you need some means of managing a list of these classes. You have a lot of options for performing this task at your disposal, but using javax.swing.event.EventListenerList is the easiest method available.

The example begins by creating an EventListenerList, ListenerList. It then provides methods for adding methods to (AddEventListener()) and removing methods from (RemoveEventListener()) the list. These methods rely on functionality provided as part of the EventListenerListclass — you don’t implement the functionality yourself.

The FireEvent() method is the centerpiece of this class. When this method is called, the caller is saying that an event has happened and that the object created from this call should tell everyone about it. The method takes one input, a MyEvent object, Event. This input argument says that a specific kind of event has happened.

To tell everyone who’s said they want to know about the event, the FireEvent() method begins by obtaining the list of methods that appear in ListenerList. An odd aspect of ListenerList is that the entries appear in every other element. You don’t need to worry about why this is the case — you simply have to know that it is. Consequently, the code creates a for loop that looks at every other element.

The list you create could contain any number of event listeners, each of which is waiting for a different event. The example ensures that the class of the event listener entry is precisely the same as the MyEventListener.class, so that you know it’s the right kind of event listener. When this is the case, the code calls the EventHappened() method within that class to tell it that the event has happened.

3. Using the standard commands of your editor or IDE, save this file as SampleEventClass.java.

4. In your command prompt, type javac SampleEventClass.java and press Enter.

The compiler compiles your application and creates a .class file from it.

Demonstrating use of the event in a class

You now have a means of using an event within a class. The example class isn’t very complex. However, it does incorporate everything you’ve learned to date about creating classes, plus it adds the information you need to know in order to add events to a class. The following example shows a simple class that lets you create an event implementation and then interact with it in a meaningful way.

Files needed: DemoClass.java

1. Open the editor or IDE that you’ve chosen to use for this book.

2. Type the following code into the editor screen.

public class DemoClass
{
// The event manager class isn't the same as an
// event manager. DoEvents is the object that
// actually manages the event for this class.
private SampleEventClass DoEvents = new SampleEventClass();

public DemoClass()
{
// You must add each object created from this class
// to the event listener list. Each object will
// receive a separate notification.
DoEvents.AddEventListener(new MyEventListener()
{
public void EventHappened(MyEvent Event)
{
if ((int)Event.getSource() >= 4)
System.out.println("Number is too high!");

if ((int)Event.getSource() <= 0)
System.out.println("Number is too low!");
}
});
}

// Create a field to manipulate for this class. The
// field could represent any data.
private int Value = 0;

// Obtain the current value of the field.
public int getValue()
{
return Value;
}

// Set the value of the field directly.
public void setValue(int Value)
{
// Create an event object that contains
// the value that the caller attempted to
// use.
MyEvent Event = new MyEvent(Value);

// When the caller tries to set the value too
// high or too low, the class must fire the
// event. Otherwise, it can change the contents
// of Value.
if ((Value <= 3) & (Value > 0))
this.Value = Value;
else
DoEvents.FireEvent(Event);
}

public void AddOne()
{
// Create an event object containing the
// current contents of Value.
MyEvent Event = new MyEvent(Value);

// Make sure that Value isn't getting too
// high. If so, fire an event.
if (Value <= 3)
Value++;
else
DoEvents.FireEvent(Event);
}

public void SubtractOne()
{
// Create an event object containing the
// current contents of Value.
MyEvent Event = new MyEvent(Value);

// Make sure that Value isn't getting too
// low. If so, fire an event.
if (Value > 0)
Value--;
else
DoEvents.FireEvent(Event);
}
}

The big thing is not to get overwhelmed by this class; take it one element at a time. The code begins by creating a SampleEventClass object, DoEvents, to manage the event that this class generates. You use DoEvents to interact with the events that this class generates in a meaningful way — a way that you’ll discover later on.

The constructor comes next. Notice that this is a generic constructor — one that doesn’t require any input arguments. However, it adds the instance of this class — the object created from DemoClass — to the event listener list by calling DoEvents.AddEventListener(). To make things easy for this example, the event handler appears directly as part of the method call. It’s a call to EventHappened(), which takes an argument of the MyEvent type, Event. When the information contained within the event (obtained by calling getSource()) is greater than or equal to 4, the application displays a message that the number is too high. Likewise, an event value less than or equal to 0 generates a message saying that the number is too low.

This is an actual class that does something other than work with events. The next step is to create an int named Value with an initial value of 0. The class manipulates the data in Value and generates events based on that content. The getValue() and setValue() methods are the getter and setter for Value. Notice that setValue() provides the special feature of checking the input value. When the input value is in the desired range, setValue() lets it pass. However, when the input value is outside of the desired range, rather than set the value, setValue() generates an event by calling DoEvents.FireEvent(). To make this call, setValue() must create a new MyEvent object, Event, that contains the incorrect value, Value. The event handler, EventHappened(), receives this information and displays the appropriate message.

The AddOne() method increments Value, while SubtractOne() decrements Value. Both of these methods also check Value for incorrect information and act accordingly.

3. Using the standard commands of your editor or IDE, save this file as DemoClass.java.

4. In your command prompt, type javac DemoClass.java and press Enter.

The compiler compiles your application and creates a .class file from it.

Using the Class with Events

At this point, you have a class to use. All you need to do is create an application to use it. In the following example, you create an application that exercises DemoClass.

Files needed: UseEvent.java

1. Open the editor or IDE that you’ve chosen to use for this book.

2. Type the following code into the editor screen.

public class UseEvent
{
public static void main(String[] args)
{
// Create a copy of the demonstration class.
DemoClass TestClass = new DemoClass();

// Value will start at 0, so keep adding 1
// until Value should equal 5.
TestClass.AddOne();
System.out.println(TestClass.getValue());
TestClass.AddOne();
System.out.println(TestClass.getValue());
TestClass.AddOne();
System.out.println(TestClass.getValue());
TestClass.AddOne();
System.out.println(TestClass.getValue());
TestClass.AddOne();
System.out.println(TestClass.getValue());

// Now that Value is at 4 (we couldn't make it
// equal 5), keep subtracting 1 until Value
// should equal -1.
TestClass.SubtractOne();
System.out.println(TestClass.getValue());
TestClass.SubtractOne();
System.out.println(TestClass.getValue());
TestClass.SubtractOne();
System.out.println(TestClass.getValue());
TestClass.SubtractOne();
System.out.println(TestClass.getValue());
TestClass.SubtractOne();
System.out.println(TestClass.getValue());

// Try setting the value directly.
TestClass.setValue(3);
System.out.println(TestClass.getValue());
TestClass.setValue(5);
System.out.println(TestClass.getValue());
TestClass.setValue(-5);
System.out.println(TestClass.getValue());
}
}

The application begins by creating a DemoClass object, TestClass. It then exercises the resulting object by testing all of its methods, properties, and events. The application begins by incrementing the value in TestClass until it exceeds the recommended value. Now that TestClass is at its limit, the application decrements the value it contains until it’s too low. Finally, the application tries setting the value in TestClass directly. In short, TestClass demonstrates the implementation of a range check. You can’t take it beyond the anticipated boundaries.

3. Using the standard commands of your editor or IDE, save this file as UseEvent.java.

4. In your command prompt, type javac UseEvent.java and press Enter.

The compiler compiles your application and creates a .class file from it.

5. Type java UseEvent and press Enter.

You see the output shown in Figure 9-5. Notice that the event handler generates a message every time the application tries to exceed the predefined range. In addition, the value remains at the last known good value.

Figure 9-5:

Working with Anonymous Inner Classes

Sometimes you don’t really need to create a formal class definition in order to make your application work correctly. For example, it’s possible to add event-handling support to an application without going through all the work you saw earlier in this chapter. An anonymous class can make your code easier to understand and more elegant. The example that follows shows a basic use of an anonymous class when working with an interface.