1. class Outer
   
2. {
   
3.         void method(final int a)
   
4.         {        
   
5.                 class Inner
   
6.                 {
   
7.                         void funtion()
   
8.                         {
   
9.                                 System.out.println(a);
   
10.                         }
    
11.                 }
    
12.                 new Inner().funtion();
    
13.         }
    
14.         
    
15. }
    
16. class Demo
    
17. {
    
18.         public static void main(String[] args)
    
19.         {
    
20.                 Outer out = new Outer();
    
21.                 out.method(7);
    
22.                 out.method(8);
    
23.         }
    
24. }
    

复制代码

为什么输出结果是7,8啊，a不应该是被锁住了么，内存释放的出来么？

a 是在函数上，也就是局部变量，用完就释放了，不影响下一个语句调用。

1，a是形式参数，是属于method方法的，在方法中无法更改。但是方法外肯定是可以被修改的。如果是实际参数，那就在任何地方都不能被更改。
2，不过一般情况下，一个方法的形参不用final修饰。只有在特殊情况下，那就是：方法内部类。一个方法内的内部类如果使用了这个方法的参数或者局部变量的话，这个参数或局部变量应该是final。

class Outer {
        /*
         * 1、final int a这个参数是method函数的参数也是method函数的局部变量
         * 2、class Inner是内部类，但也是method函数局部的内部类
         * 3、根据规则:局部的内部类要访问成员函数的局部变量时，该变量被要求声明为最终类型，即需要用final进行修饰
         *   这个是纯粹的规则，就跟语法一样，就是这么要求的。
         */
        void method( final int a) {
                class Inner {
                        void funtion() {
                                System.out.println(a);
                        }
                }
                new Inner().funtion();
        }
}
class Demo {
        public static void main(String[] args) {
                Outer out = new Outer();
                /*
                 * 1、a是标准的局部变量，在内存中的表现形式是在栈内存中。
                 * 2、out.method(7)执行时，final int a进入栈内存中，out.method(7)执行完毕后，final int a马上从栈内存中消失了
                 * 3、out.method(8)执行时跟上面第2步的效果是一样的
                 */
                out.method(7);
                out.method(8);
        }
}