It is often possible to make a service available to a wider set of inputs by focusing on the essential operations that the service requires. Interface types are used to express these common operations.

Consider the DataSet class of Chapter 6. That class provides a service, namely computing the average and maximum of a set of input values. Unfortunately, the class is suitable only for computing the average of a set of numbers. If we wanted to process bank accounts to find the bank account with the highest balance, we could not use the class in its current form. We could modify the class, like this:

public class DataSet // Modified for BankAccount objects
{
   private double sum;
   private BankAccount maximum;
   private int count;
   ...
   public void add(BankAccount x)
   {
      sum = sum + x.getBalance();
      if (count == 0 || maximum.getBalance() < x.getBalance())
          maximum = x;
      count++;
   }

public BankAccount getMaximum()
    {
      return maximum;
    }
}

Or suppose we wanted to find the coin with the highest value among a set of coins. We would need to modify the DataSet class again.

public class DataSet // Modified for Coin objects
{
   private double sum;
   private Coin maximum;
   private int count;
   ...
   public void add(Coin x)
   {
      sum = sum + x.getValue();
      if (count == 0 || maximum.getValue() < x.getValue())
          maximum = x;
      count++;
   }

   public Coin getMaximum()
   {
       return maximum;
   }
}

Clearly, the algorithm for the data analysis service is the same in all cases, but the details of measurement differ. We would like to provide a single class that provides this service to any objects that can be measured.

Suppose that the various classes agree on a method getMeasure that obtains the measure to be used in the data analysis. For bank accounts, getMeasure returns the balance. For coins, getMeasure returns the coin value, and so on. Then we can implement a DataSet class whose add method looks like this:

sum = sum + x.getMeasure();
if (count == 0 || maximum.getMeasure() < x.getMeasure())
   maximum = x;
count++;

What is the type of the variable x? Ideally, x should refer to any class that has a getMeasure method.

In Java, an interface type is used to specify required operations. We will declare an interface type that we call Measurable:

public interface Measurable
{
   double getMeasure();
}

The interface declaration lists all methods that the interface type requires. The Measurable interface type requires a single method, but in general, an interface type can require multiple methods.

Note that the Measurable type is not a type in the standard library—it is a type that was created specifically for this book, in order to make the DataSet class more reusable.

Declaring an Interface

An interface type is similar to a class, but there are several important differences:

Now we can use the interface type Measurable to declare the variables x and maximum.

public class DataSet
{
   private double sum;
   private Measurable maximum;
   private int count;
   ...
   public void add(Measurable x)
   {
      sum = sum + x.getMeasure();
      if (count == 0 || maximum.getMeasure() < x.getMeasure())
         maximum = x;
      count++;
   }

   public Measurable getMaximum()
   {
      return maximum;
   }
}

This DataSet class is usable for analyzing objects of any class that implements the Measurable interface. A class implements an interface type if it declares the interface in an implements clause. It should then implement the method or methods that the interface requires.

public class BankAccount implements Measurable
{
   ...
   public double getMeasure()
   {
      return balance;
   }
}

Figure 9.1. Attachments Conform to the Mixer's Interface

Note that the class must declare the method as public, whereas the interface need not—all methods in an interface are public.

Similarly, it is an easy matter to modify the Coin class to implement the Measurable interface.

public class Coin implements Measurable
{
   public double getMeasure()
   {
      return value;
   }
   ...
}

In summary, the Measurable interface expresses what all measurable objects have in common. This commonality makes the flexibility of the improved DataSet class possible. A data set can analyze objects of any class that implements the Measurable interface.

This is a typical usage for interface types. A service provider—in this case, the DataSet—specifies an interface for participating in the service. Any class that conforms to that interface can then be used with the service. This is similar to the way a mixer will provide rotation to any attachment that fits its interface (see Figure 1).

Implementing an Interface

Figure 9.2. UML Diagram of the DataSet Class and the Classes that Implement the Measurable Interface

Figure 2 shows the relationships between the DataSet class, the Measurable inter-face, and the classes that implement the interface. Note that the DataSet class depends only on the Measurable interface. It is decoupled from the BankAccount and Coin classes.

In the UML notation, interfaces are tagged with an indicator «interface». A dotted arrow with a triangular tip denotes the "is-a" relationship between a class and an interface. You have to look carefully at the arrow tips—a dotted line with an open arrow tip (→) denotes the "uses" relationship or dependency.

ch09/measure1/DataSetTester.java

1 /**
2    This program tests the DataSet class.
3 */
4 public class DataSetTester
5 {
6    public static void main(String[] args)
7    {
8       DataSet bankData = new DataSet();
9
10       bankData.add(new BankAccount(0));
11       bankData.add(new BankAccount(10000));
12       bankData.add(new BankAccount(2000));
13
14       System.out.println("Average balance: " + bankData.getAverage());
15       System.out.println("Expected: 4000");
16       Measurable max = bankData.getMaximum();
17       System.out.println("Highest balance: " + max.getMeasure());
18       System.out.println("Expected: 10000");
19
20       DataSet coinData = new DataSet();
21
22       coinData.add(new Coin(0.25, "quarter"));
23       coinData.add(new Coin(0.1, "dime"));
24       coinData.add(new Coin(0.05, "nickel"));
25

26         System.out.println("Average coin value: " + coinData.getAverage());
27         System.out.println("Expected: 0.133");
28         max = coinData.getMaximum();
29         System.out.println("Highest coin value: " + max.getMeasure());
30         System.out.println("Expected: 0.25");
31      }
32   }

Program Run

Average balance: 4000.0
Expected: 4000
Highest balance: 10000.0
Expected: 10000
Average coin value: 0.13333333333333333
Expected: 0.133
Highest coin value: 0.25
Expected: 0.25

2. Why can't the add method of the DataSet class have a parameter of type Object?

public class BankAccount implements Measurable
{
   ...
   double getMeasure() // Oops--should be public
   {
      return balance;
   }
}

public interface SwingConstants
{
   int NORTH = 1;
   int NORTHEAST = 2;
   int EAST = 3;
   ...
}

Interfaces are used to express the commonality between classes. In this section, we discuss when it is legal to convert between class and interface types.

Have a close look at the call

bankData.add(new BankAccount(1000));

from the test program of the preceding section. Here we pass an object of type BankAccount to the add method of the DataSet class. However, that method has a parameter of type Measurable:

public void add(Measurable x)

It it legal to convert from the BankAccount type to the Measurable type. In general, you can convert from a class type to the type of any interface that the class implements. For example,

BankAccount account = new BankAccount(1000);
Measurable meas = account; // OK

Alternatively, a Measurable variable can refer to an object of the Coin class of the preceding section because that class also implements the Measurable interface.

Coin dime = new Coin(0.1, "dime");
Measurable meas = dime; // Also OK

However, the Rectangle class from the standard library doesn't implement the Measurable interface. Therefore, the following assignment is an error:

Measurable meas = new Rectangle(5, 10, 20, 30); // Error

Figure 9.3. Variables of Class and Interface Types

Occasionally, it happens that you store an object in an interface reference and you need to convert its type back. This happens in the getMaximum method of the DataSet class. The DataSet stores the object with the largest measure, as a Measurable reference.

DataSet coinData = new DataSet();
coinData.add(new Coin(0.25, "quarter"));
coinData.add(new Coin(0.1, "dime"));
coinData.add(new Coin(0.05, "nickel"));
Measurable max = coinData.getMaximum();

Now what can you do with the max reference? You know it refers to a Coin object, but the compiler doesn't. For example, you cannot call the getName method:

String coinName = max.getName(); // Error

That call is an error, because the Measurable type has no getName method.

However, as long as you are absolutely sure that max refers to a Coin object, you can use the cast notation to convert its type back:

Coin maxCoin = (Coin) max;
String name = maxCoin.getName();

If you are wrong, and the object doesn't actually refer to a coin, a run-time exception will occur.

This cast notation is the same notation that you saw in Chapter 4 to convert between number types. For example, if x is a floating-point number, then (int) x is the integer part of the number. The intent is similar—to convert from one type to another. However, there is one big difference between casting of number types and casting of class types. When casting number types, you may lose information, and you use the cast to tell the compiler that you agree to the potential information loss. When casting object types, on the other hand, you take a riskof causing an exception, and you tell the compiler that you agree to that risk.

4. If both BankAccount and Coin implement the Measurable interface, can a Coin reference be converted to a BankAccount reference?

Measurable meas;

Measurable meas = new Measurable(); // Error

Measurable meas = new BankAccount(); // OK

When multiple classes implement the same interface, each class can implement the methods of the interface in different ways. How is the correct method executed when the interface method is invoked? We will answer that question in this section.

It is worth emphasizing once again that it is perfectly legal—and in fact very common—to have variables whose type is an interface, such as Measurable meas;

Just remember that the object to which meas refers doesn't have type Measurable. In fact, no object has type Measurable. Instead, the type of the object is some class that implements the Measurable interface. This might be an object of the BankAccount or Coin class, or some other class with a getMeasure method.

meas = new BankAccount(1000); // OK
meas = new Coin(0.1, "dime"); // OK

What can you do with an interface variable, given that you don't know the class of the object that it references? You can invoke the methods of the interface:

double m = meas.getMeasure();

The DataSet class took advantage of this capability by computing the measure of the added object, without knowing exactly what kind of object was added.

Now let's think through the call to the getMeasure method more carefully. Which getMeasure method? The BankAccount and Coin classes provide two different implementations of that method. How did the correct method get called if the caller didn't even know the exact class to which meas belongs?

The Java virtual machine locates the correct method by first looking at the class of the actual object, and then calling the method with the given name in that class. That is, if meas refers to a BankAccount object, then the BankAccount.getMeasure method is called. If meas refers to a Coin object, then the Coin.getMeasure method is called. This means that one method call

double m = meas.getMeasure();

can invoke different methods depending on the momentary contents of meas. This mechanism for locating the appropriate method is called dynamic method lookup.

Dynamic method lookup enables a programming technique called polymorphism. The term "polymorphism" comes from the Greek words for "many shapes". The same computation works for objects of many shapes, and adapts itself to the nature of the objects.

Figure 9.4. An Interface Reference Can Refer to an Object of Any Class that Implements the Interface

6. Why can you nevertheless declare a variable whose type is Measurable?

7. What does this code fragment print? Why is this an example of polymorphism?

DataSet data = new DataSet();
data.add(new BankAccount(1000));
data.add(new Coin(0.1, "dime"));
System.out.println(data.getAverage());

Worked Example 9.1 Investigating Number Sequences

Worked Example 9.1 uses a Sequence interface to investigate properties of arbitrary number sequences.

In this section, we introduce the notion of a callback, show how it leads to a more flexible DataSet class, and study how a callback can be implemented in Java by using interface types.

To understand why a further improvement to the DataSet class is desirable, consider these limitations of the Measurable interface:

Therefore, let's rethink the DataSet class. The data set needs to measure the objects that are added. When the objects are required to be of type Measurable, the responsibility of measuring lies with the added objects themselves, which is the cause of the limitations that we noted.

It would be better if we could give a method for measuring objects to a data set. When collecting rectangles, we might give it a method for computing the area of a rectangle. When collecting savings accounts, we might give it a method for getting the account's interest rate.

Such a method is called a callback. A callback is a mechanism for bundling up a block of code so that it can be invoked at a later time.

In some programming languages, it is possible to specify callbacks directly, as blocks of code or names of methods. But Java is an object-oriented programming language. Therefore, you turn callbacks into objects. This process starts by declaring an interface for the callback:

public interface Measurer
{
   double measure(Object anObject);
}

The measure method measures an object and returns its measurement. Here we use the fact that all objects can be converted to the type Object, the "lowest common denominator" of all classes in Java. We will discuss the Object type in greater detail in Chapter 10.

The code that makes the call to the callback receives an object of a class that implements this interface. In our case, the improved DataSet class is constructed with a Measurer object (that is, an object of some class that implements the Measurer interface). That object is saved in a measurer instance variable.

public DataSet(Measurer aMeasurer)
{
   sum = 0;
   count = 0;
   maximum = null;
   measurer = aMeasurer;
}

The measurer variable is used to carry out the measurements, like this:

public void add(Object x)
{
   sum = sum + measurer.measure(x);
   if (count == 0 || measurer.measure(maximum) < measurer.measure(x))
      maximum = x;
   count++;
}

The DataSet class simply makes a callback to the measure method whenever it needs to measure any object.

Finally, a specific callback is obtained by implementing the Measurer interface. For example, here is how you can measure rectangles by area. Provide a class

public class RectangleMeasurer implements Measurer
{
   public double measure(Object anObject)
   {
      Rectangle aRectangle = (Rectangle) anObject;
      double area = aRectangle.getWidth() * aRectangle.getHeight();
      return area;
   }
}

Note that the measure method must accept a parameter of type Object, even though this particular measurer just wants to measure rectangles. The method parameter types must match those of the measure method in the Measurer interface. Therefore, the Object parameter is cast to the Rectangle type:

Rectangle aRectangle = (Rectangle) anObject;

What can you do with a RectangleMeasurer? You need it for a DataSet that compares rectangles by area. Construct an object of the RectangleMeasurer class and pass it to the DataSet constructor.

Measurer m = new RectangleMeasurer();
DataSet data = new DataSet(m);

Next, add rectangles to the data set.

data.add(new Rectangle(5, 10, 20, 30));
data.add(new Rectangle(10, 20, 30, 40));
...

Figure 9.5. UML Diagram of the DataSet Class and the Measurer Interface

The data set will ask the RectangleMeasurer object to measure the rectangles. In other words, the data set uses the RectangleMeasurer object to carry out callbacks.

Figure 5 shows the UML diagram of the classes and interfaces of this solution. As in Figure 2, the DataSet class is decoupled from the Rectangle class whose objects it processes. However, unlike in Figure 2, the Rectangle class is no longer coupled with another class. Instead, to process rectangles, you provide a small "helper" class RectangleMeasurer. This helper class has only one purpose: to tell the DataSet how to measure its objects.

ch09/measure2/Measurer.java

1 /**
2    Describes any class whose objects can measure other objects.
3 */
4 public interface Measurer
5 {
6    /**
7       Computes the measure of an object.
8       @param anObject the object to be measured
9       @return the measure
10   */
11   double measure(Object anObject);
12 }

ch09/measure2/RectangleMeasurer.java

1 import java.awt.Rectangle;
2
3 /**
4    Objects of this class measure rectangles by area.
5 */
6 public class RectangleMeasurer implements Measurer
7 {
8    public double measure(Object anObject)
9    {
10       Rectangle aRectangle = (Rectangle) anObject;
11       double area = aRectangle.getWidth() * aRectangle.getHeight();
12       return area;
13    }
14 }

ch09/measure2/DataSet.java

1 /**
2    Computes the average of a set of data values.
3 */
4 public class DataSet
5 {
6    private double sum;
7    private Object maximum;
8    private int count;
9    private Measurer measurer;
10
11    /**
12       Constructs an empty data set with a given measurer.
13       @param aMeasurer the measurer that is used to measure data values
14     */
15    public DataSet(Measurer aMeasurer)
16    {
17       sum = 0;
18       count = 0;
19       maximum = null;
20       measurer = aMeasurer;
21    }
22
23    /**
24       Adds a data value to the data set.
25       @param x a data value
26    */
27    public void add(Object x)
28    {
29       sum = sum + measurer.measure(x);
30       if (count == 0 || measurer.measure(maximum) < measurer.measure(x))
31           maximum = x;
32       count++;
33    }
34
35    /**
36       Gets the average of the added data.
37       @return the average or 0 if no data has been added
38    */
39    public double getAverage()
40    {
41       if (count == 0) return 0;
42       else return sum / count;
43    }
44
45    /**
46       Gets the largest of the added data.
47       @return the maximum or 0 if no data has been added
48    */
49    public Object getMaximum()
50    {
51        return maximum;
52    }
53 }

ch09/measure2/DataSetTester2.java

1   import java.awt.Rectangle;
2

3 /**
4    This program demonstrates the use of a Measurer.
5 */
6 public class DataSetTester2
7 {
8    public static void main(String[] args)
9    {
10       Measurer m = new RectangleMeasurer();
11
12       DataSet data = new DataSet(m);
13
14       data.add(new Rectangle(5, 10, 20, 30));
15       data.add(new Rectangle(10, 20, 30, 40));
16       data.add(new Rectangle(20, 30, 5, 15));
17
18       System.out.println("Average area: " + data.getAverage());
19       System.out.println("Expected: 625");
20
21       Rectangle max = (Rectangle) data.getMaximum();
22       System.out.println("Maximum area rectangle: " + max);
23       System.out.println("Expected: "
24             + "java.awt.Rectangle[x=10,y=20,width=30,height=40]");
25    }
26 }

Program Run

Average area: 625
Expected: 625
Maximum area rectangle: java.awt.Rectangle[x=10,y=20,width=30,height=40]
Expected: java.awt.Rectangle[x=10,y=20,width=30,height=40]

9. How can you use the DataSet class of this section to find the longest String from a set of inputs?

10. Why does the measure method of the Measurer interface have one more parameter than the getMeasure method of the Measurable interface?

The RectangleMeasurer class is a very trivial class. We need this class only because the DataSet class needs an object of some class that implements the Measurer interface. When you have a class that serves a very limited purpose, such as this one, you can declare the class inside the method that needs it:

public class DataSetTester3
{
   public static void main(String[] args)
   {
      class RectangleMeasurer implements Measurer
      {
         ...

}

      Measurer m = new RectangleMeasurer();
      DataSet data = new DataSet(m);
      ...
   }
}

A class that is declared inside another class, such as the RectangleMeasurer class in this example, is called an inner class. This arrangement signals to the reader of your program that the RectangleMeasurer class is not interesting beyond the scope of this method. Since an inner class inside a method is not a publicly accessible feature, you don't need to document it as thoroughly.

You can also declare an inner class inside an enclosing class, but outside of its methods. Then the inner class is available to all methods of the enclosing class.

public class DataSetTester3
{
   class RectangleMeasurer implements Measurer
   {
       ...
   }

   public static void main(String[] args)
   {

      Measurer m = new RectangleMeasurer();
      DataSet data = new DataSet(m);
       ...
   }
}

When you compile the source files for a program that uses inner classes, have a look at the class files in your program directory—you will find that the inner classes are stored in files with curious names, such as DataSetTester3$1RectangleMeasurer.class. The exact names aren't important. The point is that the compiler turns an inner class into a regular class file.

ch09/measure3/DataSetTester3.java

1 import java.awt.Rectangle;
2
3 /**
4    This program demonstrates the use of an inner class.
5 */
6 public class DataSetTester3
7 {
8    public static void main(String[] args)
9    {
10       class RectangleMeasurer implements Measurer
11       {
12          public double measure(Object anObject)
13          {
14             Rectangle aRectangle = (Rectangle) anObject;
15              double area
16                   = aRectangle.getWidth() * aRectangle.getHeight();
17              return area;
18          }
19       }
20

21         Measurer m = new RectangleMeasurer();
22
23         DataSet data = new DataSet(m);
24
25         data.add(new Rectangle(5, 10, 20, 30));
26         data.add(new Rectangle(10, 20, 30, 40));
27         data.add(new Rectangle(20, 30, 5, 15));
28
29         System.out.println("Average area: " + data.getAverage());
30         System.out.println("Expected: 625");
31
32         Rectangle max = (Rectangle) data.getMaximum();
33         System.out.println("Maximum area rectangle: " + max);
34         System.out.println("Expected: "
35               + "java.awt.Rectangle[x=10,y=20,width=30,height=40]");
36      }
37   }

12. How many class files are produced when you compile the DataSetTester3 program?

Coin aCoin = new Coin(0.1, "dime");
data.add(aCoin);

data.add(new Coin(0.1, "dime"));

public static void main(String[] args)
{
   //  Construct an object of an anonymous class
   Measurer m = new Measurer()
      // Class declaration starts here
      {
          public double measure(Object anObject)
          {
            Rectangle aRectangle = (Rectangle) anObject;
            return aRectangle.getWidth() * aRectangle.getHeight();
          }
      };

   DataSet data = new DataSet(m);

...
}

When you work on a program that consists of multiple classes, you often want to test some of the classes before the entire program has been completed. A very effective technique for this purpose is the use of mock objects. A mock object provides the same services as another object, but in a simplified manner.

Consider a grade book application that manages quiz scores for students. This calls for a class GradeBook with methods such as

public void addScore(int studentId, double score)
public double getAverageScore(int studentId)
public void save(String filename)

Now consider the class GradingProgram that manipulates a GradeBook object. That class calls the methods of the GradeBook class. We would like to test the GradingProgram class without having a fully functional GradeBook class.

To make this work, declare an interface type with the same methods that the GradeBook class provides. A common convention is to use the letter I as the prefix for such an interface:

public interface IGradeBook
{
   void addScore(int studentId, double score);
   double getAverageScore(int studentId);
   void save(String filename);
   ...
}

The GradingProgram class should only use this interface, never the GradeBook class. Of course, the GradeBook class implements this interface, but as already mentioned, it may not be ready for some time.

In the meantime, provide a mock implementation that makes some simplifying assumptions. Saving is not actually necessary for testing the user interface. We can temporarily restrict to the case of a single student.

public class MockGradeBook implements IGradeBook
{
   private ArrayList<Double> scores;

   public void addScore(int studentId, double score)
   {
      // Ignore studentId
      scores.add(score);
   }
   double getAverageScore(int studentId)
   {
      double total = 0;
      for (double x : scores) { total = total + x; }
      return total / scores.size();
   }
   void save(String filename)
   {
      // Do nothing
   }
   ...
}

Now construct an instance of MockGradeBook and use it in the GradingProgram class. You can immediately test the GradingProgram class. When you are ready to test the actual class, simply use a GradeBook instance instead. Don't erase the mock class—it will still come in handy for regression testing.

14. Why is the technique of mock objects particularly effective when the GradeBook and GradingProgram class are developed by two programmers?

This and the following sections continue the book's graphics track. You will learn how interfaces are used when programming graphical user interfaces.

In the applications that you have written so far, user input was under control of the program. The program asked the user for input in a specific order. For example, a program might ask the user to supply first a name, then a dollar amount. But the programs that you use every day on your computer don't work like that. In a program with a graphical user interface, the user is in control. The user can use both the mouse and the keyboard and can manipulate many parts of the user interface in any desired order. For example, the user can enter information into text fields, pull down menus, click buttons, and drag scroll bars in any order. The program must react to the user commands, in whatever order they arrive. Having to deal with many possible inputs in random order is quite a bit harder than simply forcing the user to supply input in a fixed order.

In the following sections, you will learn how to write Java programs that can react to user-interface events, such as menu selections and mouse clicks. The Java windowing toolkit has a very sophisticated mechanism that allows a program to specify the events in which it is interested and which objects to notify when one of these events occurs.

Whenever the user of a graphical program types characters or uses the mouse anywhere inside one of the windows of the program, the Java windowing toolkit sends a notification to the program that an event has occurred. The windowing toolkit generates huge numbers of events. For example, whenever the mouse moves a tiny interval over a window, a "mouse move" event is generated. Whenever the mouse button is clicked, a "mouse pressed" and a "mouse released" event are generated. In addition, higher level events are generated when a user selects a menu item or button.

Most programs don't want to be flooded by boring events. For example, consider what happens when selecting a menu item with the mouse. The mouse moves over the menu item, then the mouse button is pressed, and finally the mouse button is released. Rather than receiving lots of irrelevant mouse events, a program can indicate that it only cares about menu selections, not about the underlying mouse events. However, if the mouse input is used for drawing shapes on a virtual canvas, it is necessary to closely track mouse events.

Every program must indicate which events it needs to receive. It does that by installing event listener objects. An event listener object belongs to a class that you provide. The methods of your event listener classes contain the instructions that you want to have executed when the events occur.

To install a listener, you need to know the event source. The event source is the user-interface component that generates a particular event. You add an event listener object to the appropriate event sources. Whenever the event occurs, the event source calls the appropriate methods of all attached event listeners.

This sounds somewhat abstract, so let's run through an extremely simple program that prints a message whenever a button is clicked (see Figure 6).

Figure 9.6. Implementing an Action Listener

Button listeners must belong to a class that implements the ActionListener interface:

public interface ActionListener
{
   void actionPerformed(ActionEvent event);
}

This particular interface has a single method, actionPerformed. It is your job to supply a class whose actionPerformed method contains the instructions that you want executed whenever the button is clicked. Here is a very simple example of such a listener class:

ch09/button1/ClickListener.java

1 import java.awt.event.ActionEvent;
2 import java.awt.event.ActionListener;
3
4 /**
5    An action listener that prints a message.
6 */
7 public class ClickListener implements ActionListener
8 {
9    public void actionPerformed(ActionEvent event)
10    {
11       System.out.println("I was clicked.");
12    }
13 }

We ignore the event parameter of the actionPerformed method—it contains additional details about the event, such as the time at which it occurred.

Once the listener class has been declared, we need to construct an object of the class and add it to the button:

ActionListener listener = new ClickListener();
button.addActionListener(listener);

Whenever the button is clicked, it calls

listener.actionPerformed(event);

As a result, the message is printed.

You can think of the actionPerformed method as another example of a callback, similar to the measure method of the Measurer class. The windowing toolkit calls the actionPerformed method whenever the button is pressed, whereas the DataSet calls the measure method whenever it needs to measure an object.

The ButtonViewer class, whose source code is provided at the end of this section, constructs a frame with a button and adds a ClickListener to the button. You can test this program out by opening a console window, starting the ButtonViewer program from that console window, clicking the button, and watching the messages in the console window.

ch09/button1/ButtonViewer.java

1 import java.awt.event.ActionListener;
2 import javax.swing.JButton;
3 import javax.swing.JFrame;
4
5 /**
6    This program demonstrates how to install an action listener.
7 */
8 public class ButtonViewer
9 {
10    private static final int FRAME_WIDTH = 100;
11    private static final int FRAME_HEIGHT = 60;
12
13    public static void main(String[] args)
14    {
15       JFrame frame = new JFrame();
16       JButton button = new JButton("Click me!");
17       frame.add(button);
18
19       ActionListener listener = new ClickListener();
20       button.addActionListener(listener);
21
22       frame.setSize(FRAME_WIDTH, FRAME_HEIGHT);
23       frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
24       frame.setVisible(true);
25    }
26 }

16. Why is it legal to assign a ClickListener object to a variable of type ActionListener?

class MyListener implements ActionListener
{
   public void actionPerformed()
   // Oops ... forgot ActionEvent parameter
   {
      ...

}
}

public void actionPerformed(ActionEvent event)

In the preceding section, you saw how the code that is executed when a button is clicked is placed into a listener class. It is common to implement listener classes as inner classes like this:

JButton button = new JButton("...");

// This inner class is declared in the same method as the button variable
class MyListener implements ActionListener
{
   ...
};

ActionListener listener = new MyListener();
button.addActionListener(listener);

There are two reasons for this arrangement. The trivial listener class is located exactly where it is needed, without cluttering up the remainder of the project. Moreover, inner classes have a very attractive feature: Their methods can access variables that are declared in surrounding blocks. In this regard, method declarations of inner classes behave similarly to nested blocks.

Recall that a block is a statement group enclosed by braces. If a block is nested inside another, the inner block has access to all variables from the surrounding block:

{// Surrounding block
   BankAccount account = new BankAccount();
   if (...)
   {// Inner block
      ...
      // OK to access variable from surrounding block
      account.deposit(interest);
     ...
   }  // End of inner block
   ...
}  // End of surrounding block

The same nesting works for inner classes. Except for some technical restrictions, which we will examine later in this section, the methods of an inner class can access the variables from the enclosing scope. This feature is very useful when implementing event handlers. It allows the inner class to access variables without having to pass them as constructor or method parameters.

Let's look at an example. Suppose we want to add interest to a bank account whenever a button is clicked.

JButton button = new JButton("Add Interest");
final BankAccount account = new BankAccount(INITIAL_BALANCE);

// This inner class is declared in the same method as the account and button variables.
class AddInterestListener implements ActionListener
{
   public void actionPerformed(ActionEvent event)
   {
      // The listener method accesses the account variable
      // from the surrounding block
      double interest = account.getBalance() * INTEREST_RATE / 100;
      account.deposit(interest);
   }
};

ActionListener listener = new AddInterestListener();
button.addActionListener(listener);

There is a technical wrinkle. An inner class can access surrounding localvariables only if they are declared as final. That sounds like a restriction, but it is usually not an issue in practice. Keep in mind that an object variable is final when the variable always refers to the same object. The state of the object can change, but the variable can't refer to a different object. For example, in our program, we never intended to have the account variable refer to multiple bank accounts, so there was no harm in declaring it as final.

An inner class can also access instance variables of the surrounding class, again with a restriction. The instance variable must belong to the object that constructed the inner class object. If the inner class object was created inside a static method, it can only access static variables.

Here is the source code for the program.

ch09/button2/InvestmentViewer1.java

1 import java.awt.event.ActionEvent;
2 import java.awt.event.ActionListener;
3 import javax.swing.JButton;
4 import javax.swing.JFrame;
5
6 /**
7    This program demonstrates how an action listener can access
8    a variable from a surrounding block.
9 */
10 public class InvestmentViewer1
11 {
12    private static final int FRAME_WIDTH = 120;
13    private static final int FRAME_HEIGHT = 60;
14
15    private static final double INTEREST_RATE = 10;
16    private static final double INITIAL_BALANCE = 1000;
17
18    public static void main(String[] args)
19    {
20       JFrame frame = new JFrame();
21
22       // The button to trigger the calculation
23       JButton button = new JButton("Add Interest");
24       frame.add(button);
25

26         //  The application adds interest to this bank account
27              final BankAccount account = new BankAccount(INITIAL_BALANCE);
28
29         class AddInterestListener implements ActionListener
30         {
31            public void actionPerformed(ActionEvent event)
32            {
33               // The listener method accesses the account variable
34               // from the surrounding block
35               double interest = account.getBalance() * INTEREST_RATE / 100;
36               account.deposit(interest);
37               System.out.println("balance: " + account.getBalance());
38            }
39          }
40
41         ActionListener listener = new AddInterestListener();
42         button.addActionListener(listener);
43
44         frame.setSize(FRAME_WIDTH, FRAME_HEIGHT);
45         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
46         frame.setVisible(true);
47      }
48   }

Program Run

balance: 1100.0
balance: 1210.0
balance: 1331.0
balance: 1464.1

18. If an inner class accesses a local variable from a surrounding scope, what special rule applies?

In this section, you will learn how to structure a graphical application that contains buttons. We will put a button to work in our simple investment viewer program. Whenever the button is clicked, interest is added to a bank account, and the new balance is displayed (see Figure 7).

First, we construct an object of the JButton class. Pass the button label to the constructor:

JButton button = new JButton("Add Interest");

We also need a user-interface component that displays a message, namely the current bank balance. Such a component is called a label. You pass the initial message string to the JLabel constructor, like this:

JLabel label = new JLabel("balance: " + account.getBalance());

The frame of our application contains both the button and the label. However, we cannot simply add both components directly to the frame—they would be placed on top of each other. The solution is to put them into a panel, a container for other user-interface components, and then add the panel to the frame:

JPanel panel = new JPanel();
panel.add(button);
panel.add(label);
frame.add(panel);

Figure 9.7. An Application with a Button

Now we are ready for the hard part—the event listener that handles button clicks. As in the preceding section, it is necessary to provide a class that implements the ActionListener interface, and to place the button action into the actionPerformed method. Our listener class adds interest and displays the new balance:

class AddInterestListener implements ActionListener
{
   public void actionPerformed(ActionEvent event)
   {
      double interest = account.getBalance() * INTEREST_RATE / 100;
      account.deposit(interest);
      label.setText("balance: " + account.getBalance());
   }
}

There is just a minor technicality. The actionPerformed method manipulates the account and label variables. These are local variables of the main method of the investment viewer program, not instance variables of the AddInterestListener class. We therefore need to declare the account and label variables as final so that the action-Performed method can access them.

Let's put the pieces together.

public static void main(String[] args)
{
    ...
   JButton button = new JButton("Add Interest");
   final BankAccount account = new BankAccount(INITIAL_BALANCE);
   final JLabel label = new JLabel("balance: " + account.getBalance());
   class AddInterestListener implements ActionListener
   {
      public void actionPerformed(ActionEvent event)
      {
         double interest = account.getBalance() * INTEREST_RATE / 100;
         account.deposit(interest);
         label.setText("balance: " + account.getBalance());
      }
   }

   ActionListener listener = new AddInterestListener();
   button.addActionListener(listener);
    ...
}

With a bit of practice, you will learn to glance at this code and translate it into plain English: "When the button is clicked, add interest and set the label text."

Here is the complete program. It demonstrates how to add multiple components to a frame, by using a panel, and how to implement listeners as inner classes.

ch09/button3/InvestmentViewer2.java

1 import java.awt.event.ActionEvent;
2 import java.awt.event.ActionListener;
3 import javax.swing.JButton;
4 import javax.swing.JFrame;
5 import javax.swing.JLabel;
6 import javax.swing.JPanel;
7 import javax.swing.JTextField;
8
9 /**
10    This program displays the growth of an investment.
11 */
12 public class InvestmentViewer2
13 {
14    private static final int FRAME_WIDTH = 400;
15    private static final int FRAME_HEIGHT = 100;
16
17    private static final double INTEREST_RATE = 10;
18    private static final double INITIAL_BALANCE = 1000;
19
20    public static void main(String[] args)
21    {
22       JFrame frame = new JFrame();
23
24       // The button to trigger the calculation
25       JButton button = new JButton("Add Interest");
26
27       // The application adds interest to this bank account
28       final BankAccount account = new BankAccount(INITIAL_BALANCE);
29
30       // The label for displaying the results
31       final JLabel label = new JLabel("balance: " + account.getBalance());
32
33       // The panel that holds the user-interface components
34       JPanel panel = new JPanel();
35       panel.add(button);
36       panel.add(label);
37       frame.add(panel);
38
39       class AddInterestListener implements ActionListener
40       {
41          public void actionPerformed(ActionEvent event)
42          {
43             double interest = account.getBalance() * INTEREST_RATE / 100;
44             account.deposit(interest);
45             label.setText("balance: " + account.getBalance());
46          }
47       }
48
49       ActionListener listener = new AddInterestListener();
50       button.addActionListener(listener);
51

52        frame.setSize(FRAME_WIDTH, FRAME_HEIGHT);
53        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
54        frame.setVisible(true);
55      }
56   }

20. Why was it not necessary to declare the button variable as final?

public class InvestmentViewer
      implements ActionListener // This approach is not recommended
{
   public InvestmentViewer()
   {
      JButton button = new JButton("Add Interest");
      button.addActionListener(this);
       ...
   }

   public void actionPerformed(ActionEvent event)
   {
       ...
   }
   ...
}

panel.add(button);
panel.add(label);
panel.add(carComponent);

carComponent.setPreferredSize(new Dimension(CAR_COMPONENT_WIDTH, CAR_COMPONENT_HEIGHT));

In this section we will study timer events and show how they allow you to implement simple animations.

The Timer class in the javax.swing package generates a sequence of action events, spaced apart at even time intervals. (You can think of a timer as an invisible button that is automatically clicked.) This is useful whenever you want to have an object updated in regular intervals. For example, in an animation, you may want to update a scene ten times per second and redisplay the image, to give the illusion of movement.

When you use a timer, you specify the frequency of the events and an object of a class that implements the ActionListener interface. Place whatever action you want to occur inside the actionPerformed method. Finally, start the timer.

class MyListener implements ActionListener
{
   public void actionPerformed(ActionEvent event)
    {
      Action that is executed at each timer event
    }
}

MyListener listener = new MyListener();
Timer t = new Timer(interval, listener);
t.start();

Then the timer calls the actionPerformed method of the listener object every interval milliseconds.

Our sample program will display a moving rectangle. We first supply a Rectangle-Component class with a moveBy method that moves the rectangle by a given amount.

ch09/timer/RectangleComponent.java

1 import java.awt.Graphics;
2 import java.awt.Graphics2D;
3 import java.awt.Rectangle;
4 import javax.swing.JComponent;
5
6 /**
7    This component displays a rectangle that can be moved.
8 */
9 public class RectangleComponent extends JComponent
10 {
11    private static final int BOX_X = 100;
12    private static final int BOX_Y = 100;
13    private static final int BOX_WIDTH = 20;
14    private static final int BOX_HEIGHT = 30;
15
16    private Rectangle box;
17
18    public RectangleComponent()
19    {
20       // The rectangle that the paint method draws
21       box = new Rectangle(BOX_X, BOX_Y, BOX_WIDTH, BOX_HEIGHT);
22    }
23
24    public void paintComponent(Graphics g)
25    {
26       Graphics2D g2 = (Graphics2D) g;
27
28       g2.draw(box);
29    }
30
31    /**
32       Moves the rectangle by a given amount.
33       @param x the amount to move in the x-direction
34       @param y the amount to move in the y-direction
35     */
36     public void moveBy(int dx, int dy)
37     {
38       box.translate(dx, dy);
39       repaint();
40     }
41 }

Note the call to repaint in the moveBy method. This call is necessary to ensure that the component is repainted after the state of the rectangle object has been changed. Keep in mind that the component object does not contain the pixels that show the drawing. The component merely contains a Rectangle object, which itself contains four coordinate values. Calling translate updates the rectangle coordinate values. The call to repaint forces a call to the paintComponent method. The paintComponent method redraws the component, causing the rectangle to appear at the updated location.

The actionPerformed method of the timer listener simply calls component.moveBy(1, ¹⁾. This moves the rectangle one pixel down and to the right. Since the actionPer-formed method is called many times per second, the rectangle appears to move smoothly across the frame.

ch09/timer/RectangleMover.java

1 import java.awt.event.ActionEvent;
2 import java.awt.event.ActionListener;
3 import javax.swing.JFrame;
4 import javax.swing.Timer;
5
6 /**
7    This program moves the rectangle.
8 */
9 public class RectangleMover
10 {
11    private static final int FRAME_WIDTH = 300;
12    private static final int FRAME_HEIGHT = 400;
13
14    public static void main(String[] args)
15    {
16       JFrame frame = new JFrame();
17
18       frame.setSize(FRAME_WIDTH, FRAME_HEIGHT);
19       frame.setTitle("An animated rectangle");
20       frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
21
22       final RectangleComponent component = new RectangleComponent();
23       frame.add(component);
24
25       frame.setVisible(true);
26
27       class TimerListener implements ActionListener
28       {
29          public void actionPerformed(ActionEvent event)
30          {
31             component.moveBy(1, 1);
32          }
33       }
34
35       ActionListener listener = new TimerListener();
36
37       final int DELAY = 100; // Milliseconds between timer ticks
38       Timer t = new Timer(DELAY, listener);
39       t.start();
40    }
41 }

22. What would happen if you omitted the call to repaint in the moveBy method?

If you write programs that show drawings, and you want users to manipulate the drawings with a mouse, then you need to process mouse events. Mouse events are more complex than button clicks or timer ticks.

A mouse listener must implement the MouseListener interface, which contains the following five methods:

public interface MouseListener
{
   void mousePressed(MouseEvent event);
       //  Called when a mouse button has been pressed on a component
   void mouseReleased(MouseEvent event);
       //  Called when a mouse button has been released on a component
   void mouseClicked(MouseEvent event);
       // Called when the mouse has been clicked on a component
   void mouseEntered(MouseEvent event);
       // Called when the mouse enters a component
   void mouseExited(MouseEvent event);
       // Called when the mouse exits a component
}

The mousePressed and mouseReleased methods are called whenever a mouse button is pressed or released. If a button is pressed and released in quick succession, and the mouse has not moved, then the mouseClicked method is called as well. The mouseEntered and mouseExited methods can be used to paint a user-interface component in a special way whenever the mouse is pointing inside it.

The most commonly used method is mousePressed. Users generally expect that their actions are processed as soon as the mouse button is pressed.

You add a mouse listener to a component by calling the addMouseListener method:

public class MyMouseListener implements MouseListener
{
   // Implements five methods
}

MouseListener listener = new MyMouseListener();
component.addMouseListener(listener);

In our sample program, a user clicks on a component containing a rectangle. Whenever the mouse button is pressed, the rectangle is moved to the mouse location. We first enhance the RectangleComponent class and add a moveTo method to move the rectangle to a new position.

ch09/mouse/RectangleComponent.java

1   import java.awt.Graphics;
2   import java.awt.Graphics2D;
3   import java.awt.Rectangle;
4   import javax.swing.JComponent;
5

6 /**
7    This component displays a rectangle that can be moved.
8 */
9 public class RectangleComponent extends JComponent
10 {
11    private static final int BOX_X = 100;
12    private static final int BOX_Y = 100;
13    private static final int BOX_WIDTH = 20;
14    private static final int BOX_HEIGHT = 30;
15
16    private Rectangle box;
17
18    public RectangleComponent()
19    {
20       // The rectangle that the paint method draws
21       box = new Rectangle(BOX_X, BOX_Y, BOX_WIDTH, BOX_HEIGHT);
22    }
23
24    public void paintComponent(Graphics g)
25    {
26       Graphics2D g2 = (Graphics2D) g;
27
28       g2.draw(box);
29    }
30
31    /**
32       Moves the rectangle to the given location.
33       @param x the x-position of the new location
34       @param y the y-position of the new location
35   */
36    public void moveTo(int x, int y)
37    {
38       box.setLocation(x, y);
39       repaint();
40    }
41 }

Note the call to repaint in the moveTo method. As explained in the preceding section, this call causes the component to repaint itself and show the rectangle in the new position.

Now, add a mouse listener to the component. Whenever the mouse is pressed, the listener moves the rectangle to the mouse location.

class MousePressListener implements MouseListener
{
   public void mousePressed(MouseEvent event)
   {
      int x = event.getX();
      int y = event.getY();
      component.moveTo(x, y);
   }

   // Do-nothing methods
   public void mouseReleased(MouseEvent event) {}
   public void mouseClicked(MouseEvent event) {}
   public void mouseEntered(MouseEvent event) {}
   public void mouseExited(MouseEvent event) {}
}

Figure 9.8. Clicking the Mouse Moves the Rectangle

It often happens that a particular listener specifies actions only for one or two of the listener methods. Nevertheless, all five methods of the interface must be implemented. The unused methods are simply implemented as do-nothing methods.

Go ahead and run the RectangleComponentViewer program. Whenever you click the mouse inside the frame, the top-left corner of the rectangle moves to the mouse pointer (see Figure 8).

ch09/mouse/RectangleComponentViewer.java

1 import java.awt.event.MouseListener;
2 import java.awt.event.MouseEvent;
3 import javax.swing.JFrame;
4
5 /**
6    This program displays a RectangleComponent.
7 */
8 public class RectangleComponentViewer
9 {
10   private static final int FRAME_WIDTH = 300;
11   private static final int FRAME_HEIGHT = 400;
12
13   public static void main(String[] args)
14   {
15      final RectangleComponent component = new RectangleComponent();
16
17      // Add mouse press listener
18
19      class MousePressListener implements MouseListener
20      {
21         public void mousePressed(MouseEvent event)
22         {
23            int x = event.getX();
24            int y = event.getY();
25            component.moveTo(x, y);
26         }
27

28          // Do-nothing methods
29          public void mouseReleased(MouseEvent event) {}
30          public void mouseClicked(MouseEvent event) {}
31          public void mouseEntered(MouseEvent event) {}
32          public void mouseExited(MouseEvent event) {}
33       }
34
35       MouseListener listener = new MousePressListener();
36       component.addMouseListener(listener);
37
38       JFrame frame = new JFrame();
39       frame.add(component);
40
41       frame.setSize(FRAME_WIDTH, FRAME_HEIGHT);
42       frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
43       frame.setVisible(true);
44    }
45 }

class MouseClickListener implements MouseListener
{
   public void mouseClicked(MouseEvent event)
   {
      Mouse click action
   }

   // Four do-nothing methods
   public void mouseEntered(MouseEvent event) {}
   public void mouseExited(MouseEvent event) {}
   public void mousePressed(MouseEvent event) {}
   public void mouseReleased(MouseEvent event) {}
}

class MouseClickListener extends MouseAdapter
{
   public void mouseClicked(MouseEvent event)
   {

Mouse click action
   }
}

Programming Languages

Many hundreds of programming languages exist today, which is actually quite surprising. The idea behind a high-level programming language is to provide a medium for programming that is independent from the instruction set of a particular processor, so that one can move programs from one computer to another without rewriting them. Moving a program from one programming language to another is a difficult process, however, and it is rarely done. Thus, it seems that there would be little use for so many programming languages.

Unlike human languages, programming languages are created with specific purposes. Some programming languages make it particularly easy to express tasks from a particular problem domain. Some languages specialize in database processing; others in "artificial intelligence" programs that try to infer new facts from a given base of knowledge; others in multimedia programming. The Pascal language was purposefully kept simple because it was designed as a teaching language. The C language was developed to be translated efficiently into fast machine code, with a minimum of housekeeping overhead. The C++ language builds on C by adding features for object-oriented programming. The Java language was designed for securely deploying programs across the Internet.

The initial version of the C language was designed around 1972. As different compiler writers added incompatible features, the language sprouted various dialects. Some programming instructions were understood by one compiler but rejected by another. Such divergence is an immense pain to a programmer who wants to move code from one computer to another, and an effort got underway to iron out the differences and come up with a standard version of C. The design process ended in 1989 with the completion of the ANSI (American National Standards Institute) Standard. In the meantime, Bjarne Stroustrup of AT&T added features of the language Simula (an object-oriented language designed for carrying out simulations) to C. The resulting language was called C++. From 1985 on, C++ grew by the addition of many features, and a standardization process was completed in 1998. C++ has been enormously popular because programmers can take their existing C code and move it to C++ with only minimal changes. In order to keep compatibility with existing code, every innovation in C++ had to work around the existing language constructs, yielding a language that is powerful but somewhat cumbersome to use.

In 1995, Java was designed by James Gosling to be conceptually simpler and more internally consistent than C++, while retaining the syntax that is familiar to millions of C and C++ programmers. The Java language was an immediate success, not only because it eliminated many of the cumbersome aspects of C++, but also because it included a powerful library.

James Gosling, Designer of the Java Programming Language

However, programming language evolution has not come to an end. There are aspects of programming that Java does not handle well. Computers with multiple processors are becoming increasingly common, and it is difficult to write concurrent Java programs that use multiple processors correctly and efficiently. Also, as you have seen in this chapter, it can be rather cumbersome in Java to deal with small blocks of code such as the code for measuring an object. In Java, you have to make an interface with a method for that code, and then provide a class that implements the interface. In functional programming languages, you can manipulate functions in the same way as objects, and such tasks becomes much easier. For example, in Scala, a hybrid functional/object-oriented language, you can simply construct a DataSet with a function, without having to use an interface:

data = new DataSet((x : Rectangle) => x.getWidth() * x.getHeight() )

Could the Java language be enhanced for concurrent and functional programming? Some attempts have been made, but they were not encouraging because they interacted with existing language features in complex ways. Some new languages (such as Scala) run on the same virtual machine as Java and can easily call existing Java code. Nobody can tell which languages will be most successful in the years to come, but most software developers should expect to work with multiple programming languages during their career.

java.awt.Component                          java.awt.event.MouseListener
   addMouseListener                            mouseClicked
   repaint                                     mouseEntered
   setPreferredSize                            mouseExited
java.awt.Container                             mousePressed
   add                                         mouseReleased
java.awt.Dimension                          javax.swing.AbstractButton
java.awt.Rectangle                             addActionListener
   setLocation                              javax.swing.JButton
java.awt.event.ActionListener               javax.swing.JLabel
   actionPerformed                          javax.swing.JPanel
java.awt.event.MouseEvent                   javax.swing.Timer
   getX                                        start
   getY                                        stop

C c = ...;
I i = ...;
J j = ...;

I i = new C();

Sandwich sub = new Sandwich();
Rectangle cerealBox = new Rectangle(5, 10, 20, 30);
Edible e = null;

Rectangle getBounds()

Shape s = ...;
Rectangle r = s.getBounds();

public class T
{
   private int t;

   public void m(final int x, int y)
   {
      int a;
      final int b;

      class C implements I
      {
         public void f()
         {
             ...

}
      }

      final int c;
      ...
   }
}

0: *************
1: ******************
2: *************

public interface Filter
{
   boolean accept(Object x);
}

public interface Comparable
{
   /**
      Compares this object with another.
      @param other the object to be compared
      @return a negative integer, zero, or a positive integer if this object
      is less than, equal to, or greater than, other
   */
   public int compareTo(Object other);
}

void formatTo(Formatter formatter, int flags, int width, int precision)

Appendable a = formatter.out();

void append(CharSequence sequence)

Chapter 1

Happy families are all alike; every unhappy family is unhappy in
its own way.

Everything was in confusion in the Oblonskys' house. The wife
had discovered that the husband was carrying on an intrigue with
a French girl, who had been a governess in their family, and she
had announced to her husband that she could not go on living in
the same house with him ...

<h1>Chapter 1</h1>
<p>Happy families are all alike; every unhappy family is unhappy in
its own way.</p>
<p>Everything was in confusion in the Oblonskys' house. The wife
had discovered that the husband was carrying on an intrigue with

a French girl, who had been a governess in their family, and she
had announced to her husband that she could not go on living in
the same house with him ...</p>

Date now = new Date();
System.out.println(now);

boolean isValidMove(String move)