当方法被调用运行完毕之后，局部变量就已消亡了。但内部类对象可能还存在，
直到没有被引用时才会消亡。此时就会出现一种情况，就是内部类要访问一个不存在的局部变量。
所以当方法中的内部类要访问方法中的局部变量时，必须是被final修饰的

这里，谁能帮忙举个栗子，就是方法结束后，内部类要访问局部变量的例子？

• public class Demo {
•         public static void main(String[] args) {
•                 A a = new A();
•                 a.method(1);
•                 a.method(2);
•         }
• }
• class A{
•         int x =0;
•         void method(final int b){
•                 class B{
•                         void fun(){
•                                 System.out.println(b);
•                         }
•                 }
•                 new B().fun();
•         }
• }
  

[color=rgb(177, 8, 0) !important]复制代码
被final修饰后 不是一样生命周期随着方法的结束而结束吗？不然不能重新赋值的。

1. class Ticket
   
2. {
   
3.         private String name;
   
4.         private int countTicket = 0;
   
5.         
   
6.         public Ticket(String name)
   
7.         {
   
8.                 this.name = name;               
   
9.                
   
10.                 final ExecutorService threadPool = Executors.newFixedThreadPool(1);
    
11.                 threadPool.execute(new Runnable()
    
12.                 {
    
13.                         public void run()
    
14.                         {
    
15.                                 System.out.println(Ticket.this.name + "：开始卖票了" );
    
16.                                 
    
17.                                 while(TicketSealCenter.newInstance.getTicketNumber())                //去查询售票中心 是否还有票
    
18.                                 {
    
19.                                         System.out.println(Ticket.this.name + "：卖出了他的第：" + (++countTicket) + "张票，还剩" + TicketSealCenter.newInstance.sellTicketNnumber() + "张");
    
20.                                 }
    
21.                                 System.out.println(Ticket.this.name + "：没票了，本次他共计卖出了" + countTicket + "张票");
    
22.                                 
    
23.                                 
    
24.                                 /**如使用完线程池以后，必须要记住 要关闭，不然他可是会一直,知道你的程序结束
    
25.                                  * */
    
26.                                 threadPool.shutdown();
    
27.                         }
    
28.                 });
    
29.         }
    
30. 
    
31. }

复制代码

bu 知道能不能帮你

1. public enum Lamp
   
2. {
   
3.         RED(10){
   
4.                 public Lamp nextLamp()
   
5.                 {
   
6.                         return GREEN_3;
   
7.                 }
   
8.         },
   
9.         GREEN_3(30){
   
10.                 public Lamp nextLamp()
    
11.                 {
    
12.                         return RED;
    
13.                 }
    
14.         },
    
15.         GREEN_2(20)
    
16.         {
    
17.                 public Lamp nextLamp()
    
18.                 {
    
19.                         return RED;
    
20.                 }
    
21.                
    
22.         },
    
23.         GREEN_1(10)
    
24.         {
    
25.                 public Lamp nextLamp()
    
26.                 {
    
27.                         return RED;
    
28.                 }
    
29.         };
    
30.         
    
31.         
    
32.         protected  int time;
    
33.         
    
34.         private Lamp(int time)
    
35.         {
    
36.                 this.time = time;
    
37.         }
    
38.         
    
39.         public abstract Lamp nextLamp();
    
40. }

复制代码

2个。看对你有帮助不

栗子有错别字，哈哈

1. class Outer{  
   
2.      public SuperInner outer(){  
   
3.         final int a=20;          //定义一个final局部变量a，初始化为20  
   
4.   
   
5.         class Inner implements SuperInner{              //在outer()方法中定义一个局部内部类Inner,实现接口SuperInner  
   
6.            public void m1(){    //类中只有一个覆盖接口SuperInner的方法m1()  
   
7.             
   
8.               System.out.println("Inner's m1() "+a);    //编译通过，输出：Inner's m1() 20  
   
9.            }  
   
10.         }  
    
11.         return new Inner();  
    
12.      }  
    
13. }  

复制代码

这个问题我研究过，其实final不能改变生命周期，为什么要加final了，就是把这个变量给锁起来；让这个变量不能改变值，
比如局部变量 final int a = 10 ;内部类的语句输出调用a
System.out.println(a);
锁起来这个变量之后，虚拟机在编译时期就直接把输出语句变成System.out.println(10);
所以在运行的时候虽然a消失了，但是值已经赋值上去了

0小菜鸟0 发表于 2014-8-20 23:02
这个问题我研究过，其实final不能改变生命周期，为什么要加final了，就是把这个变量给锁起来；让这个变量不 ...

感谢分享，我听说final修饰后 会在内存中复制一份相同数据，不管原来的数据有没有消失，程序调用的都是复制出来的那份。不知这种说法是否属实。

public class Outer {

        public void method() {
                final int num = 10;// 局部变量

                // 定义类
                class Inner {

                        public void show() {

                                System.out.println(num);
                        }
                }

                // 创建对象
                Inner i = new Inner();
                i.show();
        }

}

class InnerTest {
        public static void main(String[] args) {
                Outer o = new Outer();
                o.method();
        }
}

ysdolls 发表于 2014-8-21 10:05
感谢分享，我听说final修饰后 会在内存中复制一份相同数据，不管原来的数据有没有消失，程序调用的都是复 ...

是的，我说的就是这个意思，他是复制出来了，因为是常量；所以这么理解也是没错的

混迹黑马论坛，寻找一切得分的机会