where methods final variables are saved

[killutch]

Question:
When a final variable is declared with in a method does that get saved on the heap or in a stack?

Reason I Ask:
When dealing with inner class specifically ones inside methods you can't access the methods variables but you can access the class variables accept when the method has a final variable.

Example:
This compiles

public class Test{
	
	public static void main(String[] args){
		Test t = new Test();
		t.bam();
		
	}
	
	public void bam(){
		final int x = 10;
		class Foo{
			public void ya(){
				System.out.println(x);
			}
		}
		
		Foo b = new Foo();
		b.ya();
	}
	
}

This doesn't compile

public class Test{
	
	public static void main(String[] args){
		Test t = new Test();
		t.bam();
		
	}
	
	public void bam(){
		int x = 10;
		class Foo{
			public void ya(){
				System.out.println(x);
			}
		}
		Foo b = new Foo();
		b.ya();
	}
}

[eRaaaa]

If you use final variables, you have constants so the compiler can (during compilation) replace the x in your inner class to the constant value (10)
So after compilation you have something like
System.out.println(10); instead of System.out.println(x);

[JosAH]

If you use final variables, you have constants so the compiler can (during compilation) replace the x in your inner class to the constant value (10)
So after compilation you have something like
System.out.println(10); instead of System.out.println(x);

That is not true; the value of a final variable may only be known at runtime, so the compiler cannot treat it as a constant; the compiler generates code to copy the final variable as a member of the local class.

kind regards,

Jos

[eRaaaa]

Mhmm, I reffered (with "use final variables") to the example of the TO, you too ?(here we have a compile time constant expression, as described in the java language spec or?)
Take a look at the bytecodes!

The original code

public class Test{
     
    public static void main(String[] args){
        Test t = new Test();
        t.bam();
         
    }
     
    public void bam(){
        final int x = 10;
        class Foo{
            public void ya(){
                System.out.println(x);
            }
        }
        Foo b = new Foo();
        b.ya();
    }
}

the bytecode:

Compiled from "Test.java"
class Test$1Foo extends java.lang.Object{
final Test this$0;

Test$1Foo(Test);
  Code:
   0:	aload_0
   1:	aload_1
   2:	putfield	#10; //Field this$0:LTest;
   5:	aload_0
   6:	invokespecial	#12; //Method java/lang/Object."<init>":()V
   9:	return

public void ya();
  Code:
   0:	getstatic	#20; //Field java/lang/System.out:Ljava/io/PrintStream;
   3:	bipush	10
   5:	invokevirtual	#26; //Method java/io/PrintStream.println:(I)V
   8:	return

}

(take a look at the line 3: bipush 10)!!!
now my assertion (makes no difference if use final int x or only int x)

public class Test{
     
    public static void main(String[] args){
        Test t = new Test();
        t.bam();
         
    }
     
    public void bam(){
        final int x = 10;
        class Foo{
            public void ya(){
                System.out.println(10);
            }
        }
        Foo b = new Foo();
        b.ya();
    }
}

will generate exakt the same bytecode!

Compiled from "Test.java"
class Test$1Foo extends java.lang.Object{
final Test this$0;

Test$1Foo(Test);
  Code:
   0:	aload_0
   1:	aload_1
   2:	putfield	#10; //Field this$0:LTest;
   5:	aload_0
   6:	invokespecial	#12; //Method java/lang/Object."<init>":()V
   9:	return

public void ya();
  Code:
   0:	getstatic	#20; //Field java/lang/System.out:Ljava/io/PrintStream;
   3:	bipush	10
   5:	invokevirtual	#26; //Method java/io/PrintStream.println:(I)V
   8:	return

}

[killutch]

So it looks like it is known at compile time but I'm still guessing josha is right about finals getting treated like they where declared on the class level?

makes no difference if use final int x or only int x

I don't know byte code but judging off of what I see your saying they both produce the same byte code? Did both my example programs compile for you?

By the way thanks for the reply guys.

[eRaaaa]

Did both my example programs compile for you?

No your second one not, but my second one is a bit different (I use the 10 at System.out and not the variable x, so here we don`t need the final, but both of them (with final and not) produces the same bytecode here in my second example, not in yours!)

[killutch]

No your second one not, but my second one is a bit different (I use the 10 at System.out and not the variable x, so here we don`t need the final, but both of them (with final and not) produces the same bytecode here in my second example, not in yours!)

Wow interesting so the java does some tricks at compile time (I'm guessing to increase performance). If you have two programs not equal and you end up with the same byte code but looking into the byte code doesn't explain at all why one can be accessed in a method inner class. I think I'm going to adopt what Josahs said to try and remember this weird rule.

[DarrylBurke]

It's not a 'weird rule,' it's specified: Chapter*8.*Classes

Any local variable, formal parameter, or exception parameter used but not declared in an inner class must be declared final.

Any local variable used but not declared in an inner class must be definitely assigned (§16) before the body of the inner class.

db