因为如果变量不是final，就会令人困惑，因为匿名类中不会提取对它的更改。

只需要让变量“price”和“lastPrice”成为final。

——编辑

很明显，在你的函数中，你也不需要给它们赋值。您需要新的局部变量。不管怎样，我怀疑现在已经有人给了你一个更好的答案。

Java不支持真正的闭包，即使使用像您在这里使用的匿名类(new TimerTask(){…})看起来像是一种闭包。

编辑-请看下面的评论-以下是一个不正确的解释，正如keperofsoul指出的那样。

这就是为什么它不起作用:

变量lastPrice和price是main()方法中的局部变量。使用匿名类创建的对象可能会持续到main()方法返回之后。

当main()方法返回时，局部变量(如lastPrice和price)将从堆栈中清除，因此在main()返回后它们将不再存在。

但是匿名类对象引用了这些变量。如果匿名类对象在变量被清理后试图访问它们，那么事情将会发生严重的错误。

通过使lastPrice和price成为final，它们不再是真正的变量，而是常量。然后，编译器可以将匿名类中lastPrice和price的使用替换为常量的值(当然是在编译时)，这样就不会再有访问不存在的变量的问题了。

其他支持闭包的编程语言是通过特殊处理这些变量来实现的——确保它们在方法结束时不会被销毁，这样闭包仍然可以访问这些变量。

你可以这样做:

public static void main(String args[]) {
    int period = 2000;
    int delay = 2000;

    Timer timer = new Timer();

    timer.scheduleAtFixedRate(new TimerTask() {
        // Variables as member variables instead of local variables in main()
        private double lastPrice = 0;
        private Price priceObject = new Price();
        private double price = 0;

        public void run() {
            price = priceObject.getNextPrice(lastPrice);
            System.out.println();
            lastPrice = price;
        }
    }, delay, period);      
}

不能引用非最终变量，因为Java语言规范是这样规定的。8.1.3: 任何使用但未在内部类中声明的局部变量、形式方法参数或异常处理程序参数必须声明为final。整个段落。 我只能看到你的代码的一部分-根据我的调度修改局部变量是一个奇怪的想法。当你离开函数时，局部变量就不存在了。也许类的静态字段会更好?

这是另一种解释。考虑下面这个例子

public class Outer{
     public static void main(String[] args){
         Outer o = new Outer();
         o.m1();        
         o=null;
     }
     public void m1(){
         //int x = 10;
         class Inner{
             Thread t = new Thread(new Runnable(){
                 public void run(){
                     for(int i=0;i<10;i++){
                         try{
                             Thread.sleep(2000);                            
                         }catch(InterruptedException e){
                             //handle InterruptedException e
                         }
                         System.out.println("Thread t running");                             
                     }
                 }
             });
         }
         new Inner().t.start();
         System.out.println("m1 Completes");
    }
}

这里的输出是

m1完成

线程运行

线程运行

线程运行

................

现在方法m1()完成，我们将引用变量o赋值为空，现在外部类对象有资格进行GC，但内部类对象仍然存在，与正在运行的线程对象有(has - a)关系。没有外部类对象，就不可能存在m1()方法，没有m1()方法，就不可能存在它的局部变量，但如果内部类对象使用m1()方法的局部变量，那么一切都是不言自明的。

为了解决这个问题，我们必须创建一个局部变量的副本，然后必须用内部类对象将其复制到堆中，java只对final变量做了什么，因为它们实际上不是变量，它们像常量(一切都发生在编译时，而不是在运行时)。

为了解决上述问题，不同的语言做出了不同的决定。

对于Java，解决方案就像我们在本文中看到的那样。

对于c#，解决方案是允许副作用和引用捕获是唯一的选择。

对于c++ 11，解决方案是让程序员来做决定。他们可以选择通过值或引用来捕获。如果通过值捕获，则不会发生副作用，因为引用的变量实际上是不同的。如果通过引用捕获，可能会产生副作用，但程序员应该意识到这一点。

使用匿名类时，只能从包含类中访问最终变量。因此，您需要声明正在使用的变量为final(这对您来说不是一个选项，因为您正在更改lastPrice和price)，或者不要使用匿名类。

因此，您的选择是创建一个实际的内部类，您可以在其中传递变量并以正常方式使用它们

or:

对于你的lastPrice和price变量，有一个快速(在我看来很难看)的方法，就是像这样声明它

final double lastPrice[1];
final double price[1];

在匿名类中，你可以这样设置值

price[0] = priceObject.getNextPrice(lastPrice[0]);
System.out.println();
lastPrice[0] = price[0];