Using Inner Classes

In this chapter, you find out how to use three advanced types of classes: inner classes, static inner classes, and anonymous inner classes. All three are useful in certain circumstances. In particular, inner classes and anonymous inner classes are commonly used with graphical applications created with Swing. For more information about Swing, refer to Book VI. In this chapter, I just concentrate on the mechanics of creating these types of classes.

Declaring Inner Classes

An inner class is a class that's declared inside of another class. Thus the basic structure for creating an inner class is as follows:

class outerClassName { private class innerClassName { // body of inner class } }

The class that contains the inner class is called an outer class. You can use a visibility modifier with the inner class to specify whether the class should be public, protected, or private. This visibility determines whether other classes can see the inner class.

Understanding inner classes

At the surface, an inner class is simply a class that's contained inside another class. However, there's more to it than that. Here are some key points about inner classes:

• An inner class automatically has access to all the fields and methods of the outer class-even private fields and methods. Thus an inner class has more access to its outer class than a subclass has to its super-class. (A subclass can access public and protected members of its superclass, but not private members.)
• An inner class carries with it a reference to the current instance of the outer class that enables it to access instance data for the outer class.
• Because of the outer class instance reference, you can't create or refer to an inner class from a static method of the outer class. You can, however, create a static inner class, as I describe in the section "Using Static Inner Classes" later in this chapter.

• Tip

  One of the main reasons for creating an inner class is to create a class that's only of interest to the outer class. As a result, you usually declare inner classes to be private so other classes can't access them.

• Occasionally, code in an inner class needs to refer to the instance of its outer class. To do that, you list the name of the outer class followed by the dot operator and this. For example, if the outer class is named MyOuterClass, you would use MyOuterClass.this to refer to the instance of the outer class.

An example

Book III, Chapter 5 introduces an application that uses the Timer class in the Swing package (javax.swing.Timer) that displays the lines Tick… and Tock… on the console at a one-second interval. It uses a class named Ticker that implements the ActionListener interface to handle the Timer object's clock events.

Listing 7-1 shows a version of this application that implements the Ticker class as an inner class.

Listing 7-1: Tick Tock with an Inner Class

import java.awt.event.*; import javax.swing.*; public class TickTockInner { private String tickMessage = "Tick..."; → 6 private String tockMessage = "Tock..."; → 7 public static void main(String[] args) { TickTockInner t = new TickTockInner(); → 11 t.go(); → 12 } private void go() → 15 { // create a timer that calls the Ticker class // at one second intervals Timer t = new Timer(1000, new Ticker()); → 19 t.start(); // display a message box to prevent the // program from ending immediately JOptionPane.showMessageDialog(null, → 24 "Click OK to exit program"); System.exit(0); → 26 } class Ticker implements ActionListener → 29 { private boolean tick = true; public void actionPerformed(ActionEvent event) → 33 { if (tick) { System.out.println(tickMessage); → 37 } else { System.out.println(tockMessage); → 41 } tick = !tick; } } }

The Observer pattern

Event listeners in Java are part of a Java model called the Delegation Event Model. The Delegation Event Model is an implementation of a more general design pattern called the Observer pattern. This pattern is useful when you need to create objects that interact with each other when a change in the status of one of the objects occurs. The object whose changes are being monitored is called the observable object, and the object that monitors those changes is called the observer object.

The observer object registers itself with the observable object, which then notifies the observer object when its status changes.

You discover more about how Java implements this pattern for event handling in Book VI. But if you're interested, you may want to investigate the Observer and Observable interfaces that are a part of the Java API. They provide a standard way to create simple implementations of the Observer pattern.

The following paragraphs describe some of the highlights of this program:

Using Static Inner Classes

A static inner class is similar to an inner class, but doesn't require an instance of the outer class. Its basic form is the following:

class outerClassName { private static class innerClassName { // body of inner class } }

Like a static method, a static inner class can't access any non-static fields or methods in its outer class. It can, however, access static fields or methods.

Listing 7-2 shows a version of the Tick Tock application that uses a static inner class rather than a regular inner class.

Listing 7-2: Tick Tock with a Static Inner Class

import java.awt.event.*; import javax.swing.*; public class TickTockStatic { private static String tickMessage = "Tick..."; → 6 private static String tockMessage = "Tock..."; → 7 public static void main(String[] args) { TickTockStatic t = new TickTockStatic(); t.go(); } private void go() { // create a timer that calls the Ticker class // at one second intervals Timer t = new Timer(1000, new Ticker()); t.start(); // display a message box to prevent the // program from ending immediately JOptionPane.showMessageDialog(null, "Click OK to exit program"); System.exit(0); } static class Ticker implements ActionListener →29 { private boolean tick = true; public void actionPerformed( ActionEvent event) { if (tick) { System.out.println(tickMessage); } else { System.out.println(tockMessage); } tick = !tick; } } }

This version of the application and the Listing 7-1 version have only three differences:

Open table as spreadsheet

Using Anonymous Inner Classes

Anonymous inner classes (usually just called anonymous classes) are probably the strangest feature of the Java programming language. The first time you see an anonymous class, you'll almost certainly think that someone made a mistake, and that the code can't possibly compile. But compile it does, and it even works. And once you get the hang of working with anonymous classes, you'll wonder how you got by without them.

An anonymous class is a class that's defined on the spot, right at the point where you want to instantiate it. Because you code the body of the class right where you need it, you don't have to give it a name. (That's why it's called an anonymous class.)

Creating an anonymous class

The basic form for declaring and instantiating an anonymous class is this:

new ClassOrInterface () { class-body }

As you can see, you specify the new keyword followed by the name of a class or interface that specifies the type of the object created from the anonymous class. This class or interface name is followed by parentheses, which may include a parameter list that's passed to the constructor of the anonymous class. Then you code a class body enclosed in braces. This class body can include anything a regular class body can include: fields, methods, even other classes or interfaces.

Here's an example of a simple anonymous class:

public class AnonClass { public static void main(String[] args) { Ball b = new Ball() { public void hit() { System.out.println("You hit it!"); } }; b.hit(); } interface Ball { void hit(); } }

In this example, I created an interface named Ball that has a single method named hit. Then, back in the main method, I declared a variable of type Ball and used an anonymous class to create an object. The body of the anonymous class consists of an implementation of the hit method that simply displays the message You hit it! on the console. After the anonymous class is instantiated and assigned to the b variable, the next statement calls the hit method.

When you run this program, the single line You hit it! is displayed on the console.

Here are some things to ponder when you work with anonymous classes:

• You can't create a constructor for an anonymous class, because the anonymous class doesn't have a name. What would you call the constructor, anyway?
• If you list parameters in the parentheses following the class name, Java looks for a constructor in that class that matches the parameters you supply. If it finds one, that constructor is called with the parameters. If not, a compiler error is generated.
• You can't pass parameters if the anonymous class is based on an interface. That only makes sense-interfaces don't have constructors, so Java wouldn't have anything to pass the parameters to.
• An assignment statement can use an anonymous class as shown in this example. In that case, the anonymous class body is followed by a semicolon that marks the end of the assignment statement. Note that this semicolon is part of the assignment statement, not the anonymous class. (In the next section, you see an example of an anonymous class that's passed as a method parameter. In that example, the body isn't followed by a semicolon.)
• An anonymous class is a special type of inner class. So, like any inner class, it automatically has access to the fields and methods of its outer class.
• An anonymous class can't be static.

Tick Tock with an anonymous class

Listing 7-3 shows a more complex example of an anonymous class: a version of the Tick Tock application that uses an anonymous class as the action listener for the timer.

Listing 7-3: Tick Tock with an Anonymous Class

import java.awt.event.*; import javax.swing.*; public class TickTockAnonymous { private String tickMessage = "Tick..."; private String tockMessage = "Tock..."; public static void main(String[] args) → 9 { TickTockAnonymous t = new TickTockAnonymous(); t.go(); } private void go() { // create a timer that calls the Ticker class // at one second intervals Timer t = new Timer(1000, → 19 new ActionListener() → 20 { → 21 private boolean tick = true; public void actionPerformed( → 24 ActionEvent event) { if (tick) { System.out.println(tickMessage); } else { System.out.println(tockMessage); } tick = !tick; } }); → 37 t.start(); // display a message box to prevent the // program from ending immediately JOptionPane.showMessageDialog(null, "Click OK to exit program"); System.exit(0); } }

By now, you've seen enough versions of this program that you should understand how it works. The following paragraphs explain how this version uses an anonymous class as the ActionListener parameter supplied to the Timer constructor:

Open table as spreadsheet