In the JavaLanguage, this is an anonymous specialization of some class or interface. Because it is anonymous and inline, it is necessarily an ''inner'' class - i.e., defined within some other class. The following is a popular use of anonymous inner classes:

 addWindowListener( 
     new W''''''indowAdapter() {
         public void windowClosing( W''''''indowEvent e ) {
             System.exit(0); 
         } 
     });
This is the same as the following non-anonymous inner:

 public class W''''''indowClosingAdapter extends W''''''indowAdapter {
     public void windowClosing( W''''''indowEvent e ) {
         System.exit(0);
     } 
 }

 ''...''

 addWindowListener( new W''''''indowClosingAdapter() );
AnonymousInnerClass''''''es can also be used to create something like closures in the JavaLanguage. However they do not "close over" the lexical environment so they aren't TrueClosures. (They can capture the ''value'' of local variables, but they do not have access to the variable ''binding'' so they can't change the original variable. Which Java makes quite clear by only allowing InnerClass''''''es to refer to local variables that have been declared final (so no-one can change them)).

Yes.  Quite true.  So you put the variable in a class -- and then you can change it.  ;->
 class I''''ntHolder {
    public int i;
 }
----
The second example seems much clearer than the first. Naming a class makes the code more readable, even if it requires some extra keystrokes.
----
Another use of the anonymous inner class is as a shortcut convenience for declaring a local inner class and creating an instance of that class.

(Source: http://w3.one.net/~jweirich/java/compuware/java2/anoninnerclassexample.html)
(see Source for Inner.java and Transform Declaration)

        private static Linked''''''List multiple (Linked''''''List aList, final int factor) {
	return aList.collect ( new Transform() {
	    public int calculate (int n) { return n*factor; }
	});
    }
In this example, the collect() method returns a new list based upon applying a transformation to each element of an existing list. The transformation is specified by the Transform interface. The multiple() method creates an implementation of Transform and an instance in one step. Since we only need one object of this type of transform, we do not need to give the subclass a name.

Here, the syntax for instantiating the anonymous inner class is
    Transform t = new Transform () { /* implementation code */ }

----

I've used AnonymousInnerClass''''''es to make VirtuallyInitializedAccessors to create inexpensive objects whose lifetimes are just long enough to render a JavaServerPage. (3/28/01)
   mailto:kimball_sampson@discovery.com

----

AnonymousInnerClass''''''es may take a bit to get our heads around, but once we are comfortable with them, they turn into very powerful tools. However, I did once hear MartinFowler use the word "abominations" when describing the way SmallTalk''''''ers tend to use anonymous inners in java. <grin>.

Also, look out for problems with JavaSerialization with AnonymousInnerClass''''''es.

----
"Inner classes are unnecessary. ...to the point of being obscene.
(And yes, I use them '''all the time.'''  ;-)" -- JeffGrigg
(from http://groups.yahoo.com/group/extremeprogramming/message/78765 )

----
AnonymousInnerClass''''''es can do more than just override methods or couple to the containing class. They have a couple of non-obvious but useful features that help minimise the clutter of named but otherwise trivial InnerClass''''''es:

* They can reference parameters and local variables from their enclosing method providing these are declared '''final'''.
* They can have their own fields and methods; a class need be named only if its methods are to be called from outside.

This makes possible some nifty tricks, particularly in factory methods:
   Object newLightlySpecialisedObject(final String p){
     final String l="Local constant";
     return new Object(){
       String f="Non-final field";
       String newStringValue(){
         f=valueFromProtectedMethod();
         return "parameter="+p+", local="+l+", field="+f;
       }
       String toString(){return newStringValue();}
     };
   }
If you absolutely have to create a named InnerClass, see if it can be local, i.e., defined inside the method that uses it. It's sometimes worth naming a potentially anonymous class in this way, just to make it easier to spot in stack traces.

The serialization problem mentioned above applies to all non-static inner classes. Serializing the class implies serializing the enclosing class as well, because the hidden reference cannot be declared '''transient'''.

-- DavidWright

----
'''See also:''' InnerClass, BlocksInJava
----
CategoryJava CategoryClosure