Java Reference
In-Depth Information
you might define a class as an inner class to an interface would be when objects of the inner class type have
a strong logical association with the interface.
A class that implements the interface would have no direct connection with the inner class to the interface
— it would just need to implement the methods declared by the interface, but it is highly likely it would
make use of objects of the inner class type.
Interfaces and the Real World
An interface type is sometimes used to reference an object that encapsulates something that exists outside of
Java, such as a particular physical device. This is done when the external device does not require methods
implemented in Java code because all the function is provided externally. The interface method declarations
just identify the mechanism for operating on the external object.
The example of the
Port
interface in the library is exactly that. A reference of type
Port
refers to an
object that is a physical port on a sound card, such as that for the speaker or the microphone. The inner class,
Port.Info
, defines objects that encapsulate data to define a particular port. You can't create a
Port
object
directly because there is no class of type
Port
. Indeed, it doesn't necessarily make sense to do so because
your system may not have any ports. Assuming your PC has sound ports, you obtain a reference of type
Port
to an object that encapsulates a real port, such as the microphone, by calling a static method defined in
another class. The argument to the method is a reference to an object of type
Port.Info
specifying the kind
of port that you want. All the methods defined in the
Port
interface correspond to methods written in native
machine code that operate on the port. To call them you just use the
Port
reference that you have obtained.
ANONYMOUS CLASSES
There are occasions where you need to define a class for which you will only ever want to define one object
in your program, and the only use for the object is to pass it directly as an argument to a method. In this case,
as long as your class extends an existing class, or implements an interface, you have the option of defining
the class as an
anonymous class
. The definition for an anonymous class appears in the new expression, in
the statement where you create and use the object of the class, so that there is no necessity to provide a name
for the class.
I illustrate how this is done using an example. Suppose you want to define an object of a class that im-
plements the interface
ActionListener
for one-time use. You could do this as follows:
pickButton.addActionListener(new ActionListener() {
// Code to define the class
// that implements the ActionListener interface
}
);
The class definition appears in the
new
expression that creates the argument to the
addActionListen-
er()
method. This method requires a reference of type
ActionListener
— in other words, a reference to
a class that implements the
ActionListener
interface. The parentheses following the name of the inter-
face indicate you are creating an object reference of this type, and the details of the class definition appear
between the braces. The anonymous class can include data members as well as methods, but obviously not
constructors because the class has no name. Here, all the methods declared in the
ActionListener
interface
