将该变量声明为静态变量，并使用className.variable在所需的方法中引用它

对于为什么你不能做你正在尝试做的事情，已经给出了很好的解释。作为解决方案，也许可以考虑:

public class foo
{
    static class priceInfo
    {
        public double lastPrice = 0;
        public double price = 0;
        public Price priceObject = new Price ();
    }

    public static void main ( String args[] )
    {

        int period = 2000;
        int delay = 2000;

        final priceInfo pi = new priceInfo ();
        Timer timer = new Timer ();

        timer.scheduleAtFixedRate ( new TimerTask ()
        {
            public void run ()
            {
                pi.price = pi.priceObject.getNextPrice ( pi.lastPrice );
                System.out.println ();
                pi.lastPrice = pi.price;

            }
        }, delay, period );
    }
}

似乎你可以做一个比这更好的设计，但其思想是你可以将更新的变量分组在一个不变的类引用中。

使用匿名类，实际上是在声明一个“无名称”嵌套类。对于嵌套类，编译器生成一个新的独立的公共类，其中带有一个构造函数，该构造函数将使用所有变量作为参数(对于“命名”嵌套类，这始终是原始/外围类的实例)。这样做是因为运行时环境没有嵌套类的概念，因此需要从嵌套类(自动)转换到独立类。

以下面的代码为例:

public class EnclosingClass {
    public void someMethod() {
        String shared = "hello"; 
        new Thread() {
            public void run() {
                // this is not valid, won't compile
                System.out.println(shared); // this instance expects shared to point to the reference where the String object "hello" lives in heap
            }
        }.start();

        // change the reference 'shared' points to, with a new value
        shared = "other hello"; 
        System.out.println(shared);
    }
}

这是行不通的，因为这是编译器在底层所做的:

public void someMethod() {
    String shared = "hello"; 
    new EnclosingClass$1(shared).start();

    // change the reference 'shared' points to, with a new value
    shared = "other hello"; 
    System.out.println(shared);
}

原来的匿名类被编译器生成的一些独立的类所取代(代码不精确，但应该给你一个很好的想法):

public class EnclosingClass$1 extends Thread {
    String shared;
    public EnclosingClass$1(String shared) {
        this.shared = shared;
    }

    public void run() {
        System.out.println(shared);
    }
}

As you can see, the standalone class holds a reference to the shared object, remember that everything in java is pass-by-value, so even if the reference variable 'shared' in EnclosingClass gets changed, the instance it points to is not modified, and all other reference variables pointing to it (like the one in the anonymous class: Enclosing$1), will not be aware of this. This is the main reason the compiler forces you to declare this 'shared' variables as final, so that this type of behavior won't make it into your already running code.

现在，这是当你在匿名类中使用实例变量时发生的事情(这是你应该做的来解决你的问题，将你的逻辑移动到一个“实例”方法或类的构造函数):

public class EnclosingClass {
    String shared = "hello";
    public void someMethod() {
        new Thread() {
            public void run() {
                System.out.println(shared); // this is perfectly valid
            }
        }.start();

        // change the reference 'shared' points to, with a new value
        shared = "other hello"; 
        System.out.println(shared);
    }
}

这可以很好地编译，因为编译器会修改代码，这样新生成的类EnclosingClass $1将持有它被实例化的EnclosingClass实例的引用(这只是一个表示，但应该会让你继续下去):

public void someMethod() {
    new EnclosingClass$1(this).start();

    // change the reference 'shared' points to, with a new value
    shared = "other hello"; 
    System.out.println(shared);
}

public class EnclosingClass$1 extends Thread {
    EnclosingClass enclosing;
    public EnclosingClass$1(EnclosingClass enclosing) {
        this.enclosing = enclosing;
    }

    public void run() {
        System.out.println(enclosing.shared);
    }
}

就像这样，当EnclosingClass中的引用变量“shared”被重新赋值时，这发生在调用Thread#run()之前，你会看到“other hello”打印了两次，因为现在EnclosingClass$1#封闭变量将保持对它声明的类对象的引用，因此对该对象上的任何属性的更改将对EnclosingClass$1的实例可见。

关于这个主题的更多信息，你可以看到这篇优秀的博客文章(不是我写的):http://kevinboone.net/java_inner.html

使用匿名类时，只能从包含类中访问最终变量。因此，您需要声明正在使用的变量为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];

将该变量声明为静态变量，并使用className.variable在所需的方法中引用它

如果您想在匿名类中的方法调用中更改一个值，该“值”实际上是一个Future。所以，如果你用番石榴，你可以写

...
final SettableFuture<Integer> myvalue = SettableFuture<Integer>.create();
...
someclass.run(new Runnable(){

    public void run(){
        ...
        myvalue.set(value);
        ...
    }
 }

 return myvalue.get();