This chapter is from the book

You have now seen all the basic tools for object-oriented programming in
Java. This chapter shows you two advanced techniques that are very commonly
used. Despite their less obvious nature, you will need to master them to
complete your Java tool chest.

The first, called an interface, is a way of describing what
classes should do, without specifying how they should do it. A class can
implement one or more interfaces. You can then use objects of these
implementing classes anytime that conformance to the interface is required.
After we cover interfaces, we take up cloning an object (or deep copying, as it
is sometimes called). A clone of an object is a new object that has the same
state as the original but a different identity. In particular, you can modify
the clone without affecting the original. Finally, we move on to the mechanism
of inner classes. Inner classes are technically somewhat
complexthey are defined inside other classes, and their methods can access
the fields of the surrounding class. Inner classes are useful when you design
collections of cooperating classes. In particular, inner classes are important
to write concise, professional-looking code to handle graphical user interface
events.

This chapter concludes with a discussion of proxies, objects that
implement arbitrary interfaces. A proxy is a very specialized construct that is
useful for building system-level tools. You can safely skip that section on
first reading.

Interfaces

In the Java programming language, an interface is not a class but a set of
requirements for classes that want to conform to the interface.

Typically, the supplier of some service states: "If your class conforms
to a particular interface, then I'll perform the service." Let's
look at a concrete example. The sort method of the Arrays class
promises to sort an array of objects, but under one condition: The objects must
belong to classes that implement the Comparable interface.

Here is what the Comparable interface looks like:

public interface Comparable
{
int compareTo(Object other);
}

This means that any class that implements the Comparable interface is
required to have a compareTo method, and the method must take an
Object parameter and return an integer.

All methods of an interface are automatically public. For that reason,
it is not necessary to supply the keyword public when declaring a method
in an interface.

Of course, there is an additional requirement that the interface cannot spell
out: When calling x.compareTo(y), the compareTo method must
actually be able to compare two objects and return an indication whether
x or y is larger. The method is supposed to return a negative
number if x is smaller than y, zero if they are equal, and a
positive number otherwise.

This particular interface has a single method. Some interfaces have more than
one method. As you will see later, interfaces can also define constants. What is
more important, however, is what interfaces cannot supply. Interfaces
never have instance fields, and the methods are never implemented in the
interface. Supplying instance fields and method implementations is the job of
the classes that implement the interface. You can think of an interface as being
similar to an abstract class with no instance fields. However, there are some
differences between these two conceptswe will look at them later in some
detail.

Now suppose we want to use the sort method of the Arrays class
to sort an array of Employee objects. Then the Employee class must
implement the Comparable interface.

To make a class implement an interface, you have to carry out two steps:

You declare that your class intends to implement the given
interface.

You supply definitions for all methods in the interface.

To declare that a class implements an interface, use the implements
keyword:

class Employee implements Comparable

Of course, now the Employee class needs to supply the compareTo
method. Let's suppose that we want to compare employees by their salary.
Here is a compareTo method that returns -1 if the first employee's
salary is less than the second employee's salary, 0 if they are equal, and
1 otherwise.

In the interface declaration, the compareTo method was not declared
public because all methods in an interface are automatically
public. However, when implementing the interface, you must declare the method as
public. Otherwise, the compiler assumes that the method has package
visibilitythe default for a class. Then the compiler complains that
you try to supply a weaker access privilege.

NOTE

The compareTo method of the Comparable interface returns an
integer. If the objects are not equal, it does not matter what negative or
positive value you return. This flexibility can be useful when comparing integer
fields. For example, suppose each employee has a unique integer id, and
you want to sort by employee ID number. Then you can simply return id -
other.id. That value will be some negative value if the first ID number is
less than the other, 0 if they are the same ID, and some positive value
otherwise. However, there is one caveat: The range of the integers must be small
enough that the subtraction does not overflow. If you know that the IDs are not
negative or that their absolute value is at most(Integer.MAX_VALUE - 1) /
2, you are safe.

Of course, the subtraction trick doesn't work for floating-point
numbers. The difference salary - other.salary can round to 0 if the
salaries are close together but not identical.

Now you saw what a class must do to avail itself of the sorting
serviceit must implement a compareTo method. That's eminently
reasonable. There needs to be some way for the sort method to compare
objects. But why can't the Employee class simply provide a
compareTo method without implementing the Comparable
interface?

The reason for interfaces is that the Java language is strongly typed.
When making a method call, the compiler needs to be able to check that the
method actually exists. Somewhere in the sort method, there will be
statements like this:

if (a[i].compareTo(a[j]) > 0)
{
// rearrange a[i] and a[j]
. . .
}

The compiler must know that a[i] actually has a compareTo
method. If a is an array of Comparable objects, then the existence
of the method is assured, because every class that implements the
Comparable interface must supply the method.

NOTE

You would expect that the sort method in the Arrays class is
defined to accept a Comparable[] array, so that the compiler can complain
if anyone ever calls sort with an array whose element type doesn't
implement the Comparable interface. Sadly, that is not the case. Instead,
the sort method accepts an Object[] array and uses a clumsy cast:

If a[i] does not belong to a class that implements the
Comparable interface, then the virtual machine throws an exception. (Note
that the second cast to Comparable is not necessary because the explicit
parameter of the compareTo method has type Object, not
Comparable.)

int compareTo(Object otherObject) compares this object with
otherObject and returns a negative integer if this object is less than
otherObject, zero if they are equal, and a positive integer
otherwise.

NOTE

According to the language standard: "The implementor must ensure
sgn(x.compareTo(y)) = -sgn(y.compareTo(x)) for all x and
y. (This implies that x.compareTo(y) must throw an exception if
y.compareTo(x) throws an exception.)" Here, "sgn" is the
sign of a number: sgn(n) is -1 if n is negative, 0 if n equals 0, and 1
if n is positive. In plain English, if you flip the parameters of
compareTo, the sign (but not necessarily the actual value) of the result
must also flip. That's not a problem, but the implication about exceptions
is tricky. Suppose Manager has its own comparison method that compares
two managers. It might start like this:

That violates the "antisymmetry" rule. If x is an
Employee and y is a Manager, then the call
x.compareTo(y) doesn't throw an exceptionit simply compares
x and y as employees. But the reverse, y.compareTo(x)throws
a ClassCastException.

The same issue comes up when programming an equals method. However, in
that case, you simply test if the two classes are identical, and if they
aren't, you know that you should return false. However, if x
and y aren't of the same class, it is not clear whether
x.compareTo(y) should return a negative or a positive value. Maybe
managers think that they should compare larger than any employee, no matter what
the salary. But then they need to explicitly implement that check.

If you don't trust the implementors of your subclasses to grasp this
subtlety, you can declare compareTo as a final method. Then the
problem never arises because subclasses can't supply their own version.
Conversely, if you implement a compareTo method of a subclass, you need
to provide a thorough test. Here is an example:

static void sort(Object[] a) sorts the elements in the array a,
using a tuned mergesort algorithm. All elements in the array must belong to
classes that implement the Comparable interface, and they must all be
comparable to each other.

Properties of Interfaces

Interfaces are not classes. In particular, you can never use the new
operator to instantiate an interface:

x = new Comparable(. . .); // ERROR

However, even though you can't construct interface objects, you can
still declare sinterface variables.

Comparable x; // OK

An interface variable must refer to an object of a class that implements the
interface:

Next, just as you use instanceof to check if an object is of a
specific class, you can use instanceof to check if an object implements
an interface:

if (anObject instanceof Comparable) { . . . }

Just as you can build hierarchies of classes, you can extend interfaces. This
allows for multiple chains of interfaces that go from a greater degree of
generality to a greater degree of specialization. For example, suppose you had
an interface called Moveable.

Just as methods in an interface are automatically public, fields are
always public static final.

NOTE

It is legal to tag interface methods as public, and fields as
public static final. Some programmers do that, either out of habit or for
greater clarity. However, the Java Language Specification recommends not to
supply the redundant keywords, and we follow that recommendation.

Some interfaces define just constants and no methods. For example, the
standard library contains an interface SwingConstants that defines
constants NORTH, SOUTH, HORIZONTAL, and so on. Any class
that chooses to implement the SwingConstants interface automatically
inherits these constants. Its methods can simply refer to NORTH rather
than the more cumbersome SwingConstants.NORTH.

While each class can only have one superclass, classes can implement
multiple interfaces. This gives you the maximum amount of flexibility in
defining a class's behavior. For example, the Java programming language has
an important interface built into it, called Cloneable. (We will discuss
this interface in detail in the next section.) If your class implements
Cloneable, the clone method in the Object class will make
an exact copy of your class's objects. Suppose, therefore, you want
cloneability and comparability. Then you simply implement both interfaces.

class Employee implements Cloneable, Comparable

Use commas to separate the interfaces that describe the characteristics that
you want to supply.

Interfaces and Abstract Classes

If you read the section about abstract classes in Chapter 5, you may wonder
why the designers of the Java programming language bothered with introducing the
concept of interfaces. Why can't Comparable simply be an abstract
class:

There is, unfortunately, a major problem with using an abstract base class to
express a generic property. A class can only extend a single class. Suppose
that the Employee class already extends a different class, say
Person. Then it can't extend a second class.

class Employee extends Person, Comparable // ERROR

But each class can implement as many interfaces as it likes:

class Employee extends Person implements Comparable // OK

Other programming languages, in particular C++, allow a class to have more
than one superclass. This feature is called multiple inheritance. The
designers of Java chose not to support multiple inheritance because it makes the
language either very complex (as in C++) or less efficient (as in Eiffel).

Instead, interfaces give most of the benefits of multiple inheritance while
avoiding the complexities and inefficiencies.

NOTE

C++ has multiple inheritance and all the complications that come with it,
such as virtual base classes, dominance rules, and transverse pointer casts. Few
C++ programmers use multiple inheritance, and some say it should never be used.
Other programmers recommend using multiple inheritance only for
"mix-in" style inheritance. In the mix-in style, a primary base class
describes the parent object, and additional base classes (the so-called mix-ins)
may supply auxiliary characteristics. That style is similar to a Java class with
a single base class and additional interfaces. However, in C++, mix-ins can add
default behavior, whereas Java interfaces cannot.

NOTE

Microsoft has long been a proponent of using interfaces instead of using
multiple inheritance. In fact, the Java notion of an interface is essentially
equivalent to how Microsoft's COM technology uses interfaces. As a result
of this unlikely convergence of minds, it is easy to supply tools based on the
Java programming language to build COM objects (such as ActiveX controls). This
is done (pretty much transparently to the coder) in, for example,
Microsoft's J++ product and is also the basis for Sun's
JavaBeans-to-ActiveX bridge.

Interfaces and Callbacks

A common pattern in programming is the callback pattern. In this
pattern, you want to specify the action that should occur whenever a particular
event happens. For example, you may want a particular action to occur when a
button is clicked or a menu item is selected. However, since you have not yet
seen how to implement user interfaces, we will consider a similar but simpler
situation.

The javax.swing class contains a Timer class that is useful if
you want to be notified whenever a time interval has elapsed. For example, if a
part of your program contains a clock, then you can ask to be notified every
second so that you can update the clock face.

When you construct a timer, you set the time interval, and you tell it what
it should do whenever the time interval has elapsed.

How do you tell the timer what it should do? In many programming languages,
you supply the name of a function that the timer should call periodically.
However, the classes in the Java standard library take an object-oriented
approach. You pass an object of some class. The timer then calls one of the
methods on that object. Passing an object is more flexible than passing a
function because the object can carry additional information.

Of course, the timer needs to know what method to call. The timer requires
that you specify an object of a class that implements the ActionListener
interface of the java.awt.event package. Here is that interface:

The timer calls the actionPerformed method when the time interval has
expired.

NOTE

As you saw in Chapter 5, Java does have the equivalent of function pointers,
namely, Method objects. However, they are difficult to use, slower, and
cannot be checked for type safety at compile time. Whenever you would use a
function pointer in C++, you should consider using an interface in Java.

Suppose you want to print a message "At the tone, the time is . .
.," followed by a beep, once every ten seconds. You need to define a class
that implements the ActionListener interface. Then place whatever
statements you want to have executed inside the actionPerformed
method.

Note the ActionEvent parameter of the actionPerformed method.
This parameter gives information about the event, such as the source object that
generated itsee Chapter 8 for more information. However, detail
information about the event is not important in this program, and you can safely
ignore the parameter.

Next, you construct an object of this class and pass it to the Timer
constructor.

The first parameter of the Timer constructor is the time interval that
must elapse between notifications, measured in milliseconds. We want to be
notified every ten seconds. The second parameter is the listener object.

Finally, you start the timer.

t.start();

Every ten seconds, a message like

At the tone, the time is Thu Apr 13 23:29:08 PDT 2000

is displayed, followed by a beep.

Example 62 puts the timer and its action listener to work. After the
timer is started, the program puts up a message dialog and waits for the user to
click the Ok button to stop. While the program waits for the user, the current
time is displayed in ten second intervals.

Be patient when running the program. The "Quit program?" dialog box
appears right away, but the first timer message is displayed after ten
seconds.

Note that the program imports the javax.swing.Timer class by name, in
addition to importing javax.swing.* and java.util.*. This breaks
the ambiguity between javax.swing.Timer and java.util.Timer, an
unrelated class for scheduling background tasks.

static void showMessageDialog(Component parent, Object message)
displays a dialog box with a message prompt and an Ok button. The dialog is
centered over the parent component. If parent is null, the
dialog is centered on the screen.