Anonymous Class Indentation and Formatting

The common indentation and formatting conventions we are familiar with for languages like Java and C begin to break down somewhat once we start placing class definitions within arbitrary expressions. Based on their experience with inner classes, the engineers at JavaSoft recommend the following formatting rules, which are followed in Example 5.8:

• The opening curly brace should not be on a line by itself; instead, it should follow the close parenthesis of the new operator. Similarly, the new operator should, when possible, appear on the same line as the assignment or other expression of which it is a part.

• The body of the anonymous class should be indented relative to the beginning of the line that contains the new keyword.

• The closing curly brace of an anonymous class should not be on a line by itself either; it should be followed by whatever tokens are required by the rest of the expression. Often this is a semicolon or a close parenthesis followed by a semicolon. This extra punctuation serves as a flag to the reader that this is not just an ordinary block of code, and makes it easier to make sense of anonymous classes in a code listing.

Anonymous Classes versus Local Classes

As we've discussed, an anonymous class behaves just like a local class, and is distinguished from a local class merely in the syntax used to define and instantiate it. In your own code, when you have to choose between using an anonymous class or using a local class, the decision often comes down to stylistic matters. You should use whichever syntax makes your code clearer. In general, you should consider using an anonymous class instead of a local class if:

• The class has a very short body.

• Only one instance of the class is needed.

• The class is used right after it is defined.

• The name of the class does not make your code any easier to understand.

When considering the use of an anonymous class, there are two important restrictions to bear in mind:

• An anonymous class has no name, and the syntax for defining one combines definition with instantiation. Thus, using an anonymous class instead of a local class is not appropriate if you need to create more than a single instance of the class each time the containing block is executed.

• It is not possible to define constructors for anonymous classes. If your class requires a constructor, you must use a local class instead. However, as we'll see, the Java syntax has been extended to allow "instance initializers" to be defined for a class; an instance initializer can often substitute for a constructor.

Consider Example 5.9, which shows the Enumeration class we've used throughout this chapter implemented as an anonymous class within the enumerate() method of the LinkedList class. Compare it with Example 5.5, which shows the same class implemented as a local class. In this case, because of the size of the class in question, using local class syntax probably results in code that is a little clearer. Still, if you are a fan of anonymous classes, you might choose to code the example in this way.

import java.util.*;
public class LinkedList 
{
  // Our nested top-level interface.  Body omitted here...
  public interface Linkable { ... } 
  // The head of the list.
  /* private */ Linkable head;  
  // Method bodies omitted here.
  public void addToHead(Linkable node) { ... }
  public Linkable removeHead() { ...  }
  // This method creates and returns an Enumeration object for this 
  // LinkedList.
  public Enumeration enumerate() 
  {
    // Instantiate and return this implementation.
    return new Enumeration() { 
      Linkable current = head; // This used to be in the constructor, but
                               // anonymous classes don't have constructors.
      public boolean hasMoreElements() {  return (current != null); }
      public Object nextElement() {
        if (current == null) throw new NoSuchElementException("LinkedList");
        Object value = current;
        current = current.getNext();
        return value;
      }
    };  // Note the required semicolon.  It terminates the return statement.
  }
}

As another example, consider Example 5.10, which shows the createMenuItem() method of Example 5.6 rewritten to use an anonymous class instead of a local class. In this case, using an anonymous class is probably the right thing to do.

MenuItem createMenuItem(String label, char shortcut, final int command)
{
  // First we create a MenuItem object.
  MenuItem item = new MenuItem(label, new MenuShortcut(shortcut));
  // Then we register an anonymous ActionListener for our new MenuItem.
  item.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) { app.doCommand(command); }
  });
  // And return the item, ready to be inserted into a menu.
  return item;
}

New Java Syntax for Anonymous Classes

We've already seen examples of the syntax for defining and instantiating an anonymous class. More formally, we can write it as the following:

new class-name ( [ argument-list ] ) { class-body }

or

new interface-name () { class-body }

There is one additional new piece of syntax to support anonymous classes. As noted, anonymous classes cannot define constructors, since they do not have names. Therefore Java 1.1 adds a feature known as an instance initializer, which is similar to the static initializer of Java 1.0. Example 5.11 illustrates this new syntax.

public class InitializerDemo 
{
  // This is an instance variable.
  public int[] array1;
  // This is an instance initializer.  It is an arbitrary block of code.
  // It runs for every new instance, after the superclass constructor 
  // and before the class constructor, if any.  It can serve the same
  // function as a constructor with no arguments.
  { 
    array1 = new int[10];
    for(int i = 0; i < 10; i++) array1[i] = i; 
  }
  // The line below contains another instance initializer.  The instance
  // initializers for an object are run in the order in which they appear
  // in the class definition.
  int[] array2 = new int[10]; { for(int i=0; i<10; i++) array2[i] = i*2; }
  static int[] static_array = new int[10];
  // By contrast, the block below is a static initializer.  Note the static
  // keyword.  It runs only once, when the class is first loaded.
  static { 
    for(int i = 0; i < 10; i++) static_array[i] = i; 
  }
}

An instance initializer is simply a block of code inside curly braces that is embedded in a class definition, where a field or method definition normally appears. [11] A class (any class--not just anonymous classes) can have any number of instance initializers. The instance initializers and any variable initializers that appear in field definitions for the class are executed in the order they appear in the Java source code. These initializers are automatically run after the superclass constructor has returned but before the constructor, if any, of the current class runs.

[11] Notice that Java 1.1 now allows blocks of code to be inserted in class definitions, and local class definitions to be inserted in blocks of code.

Because an instance initializer can serve the same function as a no-argument constructor method, these initializers are particularly useful for anonymous classes. They can also be useful in non-anonymous classes. Instance initializers allow you to initialize an object's fields near the definition of those fields, rather than deferring that initialization to a constructor defined further away in the class. Used in this way, they can sometimes improve code readability.

Restrictions on Anonymous Classes

Because anonymous classes are just a type of local class, they share the same restrictions: an anonymous class cannot define any static fields, methods, or classes. Since nested interfaces are implicitly static, they cannot be defined within anonymous classes. Similarly, interfaces cannot be defined anonymously.

Anonymous classes, like local classes, cannot be public, private, protected, or static. In fact, the syntax for defining anonymous classes does not allow any modifiers to be specified.