It is common in Java programming to encounter situations
where you need to create an object but don't need to bother giving
it an explicit name. For example, to obtain the size of a panel
you can use statements like these:
Dimension
d = getSize();
int width = d.width;
int height = d.height;
where a Dimension
object is returned from a method and then used to obtain the width
and height values. But why bother creating a variable for this since
it will never be used again and will only take up memory space.
Instead, you could replace that code with this:
int
width = getSize().width;
int height = getSize().height;
where the compiler keeps track of the Dimension
object from which you obtain the width and height.
You can in fact cascade several such calls, using
the object returned in the left method to call the next method on
the right:
a
= getA().methodB().aMethodC().variableX;
This anonymity eliminates a lot unnecessary
named objects and makes it more readable.
With the inner classes
we can take this to another level by creating and instantiating
a class without bothering to give it a name. In the code below an
instance of the ActionListener
class is created in the argument of the addActionListener
method:
..
public
class AnOuterClass extends
Applet
{
Button fBt = new
Button("OK");
public AnOuterClass
()
{
int
i = 0;
fBt.addActionListener
( // The
argument is the object created by the following:
new
ActionListener () //
no name given to this object
{
public
void actionPerformed (ActionEvent
e) {
i++;
System.out.println
("Pressed "+i+" times");
}
}
);
add(fBt);
}
} // class
AnOuterClass
|
Here in one step we created an implementation of the
ActionListener
interface and created an instance of it for use by the button.
Now the compiler will create a class file name AnOuterClass$1.class
where a number, in this case "1", is used to identify
the class files for anonymous inner classes.
Latest update: Nov. 3, 2004
|