Java Reference
In-Depth Information
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 since there is no class of type Port . Indeed it doesn't necessarily make sense to do
so since 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 would be a reference to an object of type
Port.Info specifying the kind of port that you want. All of the methods defined in the Port interface
would correspond to methods written in native machine code that would 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.
We will illustrate how this is done using an example. Supposing we want to define an object of a class
that implements the interface ActionListener for one time use. We 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
addActionListener() 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 interface indicate we are creating an object reference of this type, and the
details of the class definition appear between the parentheses. 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 would need to be defined.
If the anonymous class extends an existing class, the syntax is much the same. In this case you are
calling a constructor for the base class and, if this is not a default constructor, you can pass arguments to
it by specifying them between the parentheses following the base class name. The definition of the
anonymous class must appear between braces, just as in the previous example.
Search WWH ::




Custom Search