Local inner class scope

Question

Hello all,
I am working out of "Thinking in Java" and ran across something I simply don't get. A method is called and passed an argument. This method defines an inner class and returns reference to it. Later a method in the inner class is invoked, but it still has access to the argument passed to the method that created the inner class and completed.
Here is the code (shortened from the book):
interface Counter {
     int next();
} // close interface Counter
public class LocalInnerClass {
     private int count = 0;
     Counter getCounter( final String name ) {
          class LocalCounter implements Counter {
               public int next() {
                    System.out.print( name );
                    return count++;
               } // close next()
          } // close inner class
          return new LocalCounter();
     } // close getCounter()
     public static void main( String[] args ) {
          LocalInnerClass lic = new LocalInnerClass();
          Counter c1 = lic.getCounter( "Local inner " );
          for( int i = 0; i < 5; i++ ) {
               System.out.println( c1.next() );
          } // close for
     } // close main()
} // close classAnd here is what is produced from running this:
Local inner 0
Local inner 1
Local inner 2
Local inner 3
Local inner 4The string "Local inner" is passed to the method getCouter as a final String. getCounter creates the class and exits. Later a method in getCounter uses that final String "next". This is where I am lost - getCounter is done and gone, so how the heck is name accessible to the inner class?!?!
Just when I thought I was getting the hang of this ;)

Answer 1

So trying to redeem myself...
You can use "javap -c" to see what a compiler is really doing.
So using javap (version 1.4.2_04) on the inner class gives the following....
class LocalInnerClass$1LocalCounter extends java.lang.Object implements Counter{
LocalInnerClass$1LocalCounter(LocalInnerClass,java.lang.String);
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   aload_0
   5:   aload_1
   6:   putfield        #2; //Field this$0:LLocalInnerClass;
   9:   aload_0
   10:  aload_2
   11:  putfield        #3; //Field val$name:Ljava/lang/String;
   14:  return
public int next();
  Code:
   0:   getstatic       #4; //Field java/lang/System.out:Ljava/io/PrintStream;
   3:   aload_0
   4:   getfield        #3; //Field val$name:Ljava/lang/String;
   7:   invokevirtual   #5; //Method java/io/PrintStream.print:(Ljava/lang/String;)V
   10:  aload_0
   11:  getfield        #2; //Field this$0:LLocalInnerClass;
   14:  invokestatic    #6; //Method LocalInnerClass.access$008:(LLocalInnerClass;)I
   17:  ireturn
The second method in the above is the next() method.
The next() method uses the "getfield" bytecode to retrieve a member variable of the class which is named "val$name".
The first method in the above is a constructor which takes a string as the only parameter. That string is saved in the member variable of the class called "val$name".
It is preserving a reference, so if a StringBuffer was used rather than a String then one could alter the value in the for loop of the original code and see the change.