黑马程序员技术交流社区

标题: 内部类要访问局部变量...的问题 [打印本页]
作者: ysdolls    时间: 2014-8-20 17:15
标题: 内部类要访问局部变量...的问题
当方法被调用运行完毕之后，局部变量就已消亡了。但内部类对象可能还存在，
直到没有被引用时才会消亡。此时就会出现一种情况，就是内部类要访问一个不存在的局部变量。
所以当方法中的内部类要访问方法中的局部变量时，必须是被final修饰的

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

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

作者: masai158    时间: 2014-8-20 17:15
本帖最后由 masai158 于 2014-8-20 17:25 编辑
  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.         }

  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个。看对你有帮助不
作者: 刘瑞    时间: 2014-8-20 17:19
栗子有错别字，哈哈
作者: 刘瑞    时间: 2014-8-20 17:31
  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. }  
复制代码
作者: 0小菜鸟0    时间: 2014-8-20 23:02
这个问题我研究过，其实final不能改变生命周期，为什么要加final了，就是把这个变量给锁起来；让这个变量不能改变值，
比如局部变量 final int a = 10 ;内部类的语句输出调用a
System.out.println(a);
锁起来这个变量之后，虚拟机在编译时期就直接把输出语句变成System.out.println(10);
所以在运行的时候虽然a消失了，但是值已经赋值上去了
作者: ysdolls    时间: 2014-8-21 10:05
0小菜鸟0 发表于 2014-8-20 23:02
这个问题我研究过，其实final不能改变生命周期，为什么要加final了，就是把这个变量给锁起来；让这个变量不 ...

感谢分享，我听说final修饰后 会在内存中复制一份相同数据，不管原来的数据有没有消失，程序调用的都是复制出来的那份。不知这种说法是否属实。
作者: hsy    时间: 2014-8-21 11:12
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();
        }
}
作者: 0小菜鸟0    时间: 2014-8-21 23:04
ysdolls 发表于 2014-8-21 10:05
感谢分享，我听说final修饰后 会在内存中复制一份相同数据，不管原来的数据有没有消失，程序调用的都是复 ...

是的，我说的就是这个意思，他是复制出来了，因为是常量；所以这么理解也是没错的
作者: 静水流华    时间: 2014-8-30 22:12
混迹黑马论坛，寻找一切得分的机会



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2