• Static Nested and Inner Classes:
  • Allow a class that is tightly coupled to another class to be declared and defined within it
• Types:
  • Static nested classes - an instance of the inner class can only refer to members of the outer class using an object reference (e.g., a comparator associated with a class)
  • Inner classes - an instance of the inner class exists within an instance of the outer class and has access to its members (e.g., an iterator associated with a collection)

• Local Classes:
  • A class that is defined in a block
• Purpose:
  • Allows for the inclusion of classes that are tightly coupled to the block

• Motivation:
  • Sometimes you only need to use a local class once (i.e., in one part of the outer class) so there is no reason to name it
• Difference from a Local Class:
  • An anonymous class is an expression (not a declaration) so it must be defined in another expression

• Similar To:
  • The invocation of a constructor
• The Difference:
  • There is a block of code that contains a class definition
• The Resulting Syntax:
  • The new operator
  • The name of the interface to implement or class to extend
  • Parentheses and the arguments to a construtor
  • A body containing method declarations

• Remember:
  • The expression must be a part of a complete statement
• Contents:
  • An anonymous class can't include any constructors

• Members in the Enclosing Class:
  • The anonymous class can access all members
• Access to Local Variables:
  • The anonymous class can access all local variables that are declared to be final or (since Java v8) are effectively final

• In General:
  • Situations in which you need an object that implements an interface or extends a class and exposing the class would cause confusion
• In Particular - Graphical User Interfaces:
  • For subjects/listeners (in the sense of the observer pattern)
  • For models (in the sense of the model-view-controller pattern)

javaexamples/nested/StackTextField.java

import javax.swing.*;
import javax.swing.text.*;

/**
 * A JTextField that behaves like a stack in the sense that
 * characters can only be added and removed from the "top"
 * (i.e., right side) of the String.
 *  
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 *
 */
public class StackTextField extends JTextField
{
  private static final long serialVersionUID = 1L;

  /**
   * Default Constructor.
   */
  public StackTextField()
  {
    Document model = new PlainDocument()
      /*
       * An anonymous class that overrides some methods in
       * the PlainDocument class.
       */
      {
        private static final long serialVersionUID = 1L;

        /**
         * Handle insertString messages.
         * 
         * @param offs  The offset
         * @param s     The String to insert
         * @param a     The AttributeSet describing the inserted String
         */
        public void insertString(int offs, String s, AttributeSet a)
          throws BadLocationException
        {
          if (offs == getLength()) super.insertString(offs, s, a);
        }
      
        /**
         * Handle remove messages.
         * 
         * @param offs The offset
         * @param len  The number of characters to remove
         */
        public void remove(int offs, int len)
          throws BadLocationException
        {
          if (offs + len == getLength()) super.remove(offs, len);
        }
      
      }; // Note the ; since the expression must part of a statement
    this.setDocument(model);
  }
  
}
        

javaexamples/nested/ComparatorExample.java (Fragment: anonymous)

    Arrays.sort(data, new Comparator<String>()
        {
          public int compare(String a, String b)
          {
            if (a == null) a = "";
            if (b == null) b = "";
        
            if      (a.length() > b.length()) return  1;
            else if (a.length() < b.length()) return -1;
            else                              return  0;
          }      
        });