Because anonymous classes have no names, the names of the class files that
represent them are an implementation detail. The Oracle/OpenJDK javac uses
numbers to provide anonymous class names (e.g., EnclosingType$1.class ).
A local class is named according to a combination (e.g., EnclosingType$1Mem
Let's also take a quick look at some implementation details of how javac provides
synthetic access for some of the specific cases that nested types need.
Nonstatic member class implementation
Each instance of a nonstatic member class is associated with an instance of the
enclosing class. The compiler enforces this association by defining a synthetic field
named this$0 in each member class. This field is used to hold a reference to the
Every nonstatic member class constructor is given an extra parameter that
initializes this field. Every time a member class constructor is invoked, the compiler
automatically passes a reference to the enclosing class for this extra parameter.
Local and anonymous class implementation
A local class is able to refer to fields and methods in its containing class for exactly
the same reason that a nonstatic member class can; it is passed a hidden reference to
the containing class in its constructor and saves that reference away in a private
synthetic field added by the compiler. Like nonstatic member classes, local classes
can use private fields and methods of their containing class because the compiler
inserts any required accessor methods.
What makes local classes different from member classes is that they have the ability
to refer to local variables in the scope that defines them. The crucial restriction on
this ability, however, is that local classes can reference only local variables and
parameters that are declared final . The reason for this restriction becomes appa‐
rent in the implementation.
A local class can use local variables because javac automatically gives the class a
private instance field to hold a copy of each local variable the class uses.
The compiler also adds hidden parameters to each local class constructor to initial‐
ize these automatically created private fields. A local class does not actually access
local variables but merely its own private copies of them. This could cause inconsis‐
tencies if the local variables could alter outside of the local class. 3
3 We will have more to say on this subject when we discuss memory and mutable state in Chap‐
ter 6 .