🚀 go-pugleaf

On Sat, 24 Mar 2001 11:47:05 +0200, Yonatan Taub wrote:

> How about my other question about variables referred from
> inner classes?

Sorry - I missed the other question.

> > When referring to outer objects or variables within an
> > inner class they have to be declared final otherwise you
> > get a compilation error.
> >
> > What's the reason for that?

I have no specific knowledge of Java designers' reasoning on this 
point, but I think it is a matter of readability of the code rather 
than a technical reason that makes this absolutely necessary.

When an inner class makes reference to variables in an outer scope, the 
compiler implements it by passing the values to a hidden constructor, 
and the constructor stores them in synthetic member variables.  Since 
the variables must be final, it is very clear which value is passed in 
to the inner class.  If that were not required, it would be less clear.

Take the following (invalid) code as an example:

   class InnerDemo {
      void method() {
         int i = 1;
         class Inner() {
            public void innerMethod() {
               System.out.println( i );
            }
         }
         ++ i;
         Inner inner = new Inner();
         inner.innerMethod();
      }
   }

This would be compiled into the equivalent of this:

   class InnerDemo {
      void method() {
         int i = 1;

         ++ i;
         InnerDemo$1$ inner = new InnerDemo$1$(i);
         inner.innerMethod();
      }
   }

   class InnerDemo$1$Inner() {
      private int val$i;
      public InnerDemo$1$Inner( int i ) {
         val$i = i;
      }
      public void innerMethod() {
         System.out.println( val$i );
      }
   }

The value of "i" is passed to the inner class constructor and stored in 
the synthetic member variable "val$i".  This happens at the time that 
the inner class instance is constructed, although it is very easy to 
think that the inner class gets the values from the enclosing scope at 
the point at which the inner class is declared.

So in the first example, it would be very easy to think that the value 
printed out would be 1, although the second code snippet makes it clear 
that the value would be 2.

By only allowing references to final variables in the outer scope, it 
eliminates the possibility of confusion.  Since the variable's value 
never changes, it is clear which value the inner class code gets.

Anyway, that is my theory as to the reason.  If anyone has other ideas 
or any specific knowledge on why this was done, please post a message.  
Of course, Gosling and company could clear this all up by writing "The 
Design and Evolution of Java", but as of yet they have not.

-- 
Regards,

John McGrath [TeamB]

---------------------------------------------------
Before sending me e-mail, please read:
    http://www.JPMcGrath.net/newsgroups/e-mail.html