在不同方法中定义的内部类无法引用非最终变量。

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

使用 ClassName.this.variableName 引用非 final 变量。

如果需要将变量定义为 final，但是实际上无法这样做，则可以将该变量的值赋给另一个变量，并将该变量定义为 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 完成

线程 t 正在运行

线程 t 正在运行

线程 t 正在运行

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

现在方法m1()已经完成，我们将引用变量o赋值为null，现在外部类对象符合GC的条件，但内部类对象仍然存在，并且与正在运行的Thread对象具有(Has-A)关系。如果不存在外部类对象，则不存在m1()方法的可能性，如果不存在m1()方法，则不存在其局部变量的可能性，但是如果内部类对象使用m1()方法的局部变量，则一切都是不言自明的。

为了解决这个问题，我们必须创建局部变量的副本，然后将它们与内部类对象一起复制到堆中，Java只对final变量执行此操作，因为它们实际上不是变量，而是常量(所有操作仅在编译时发生，而不是在运行时)。

主要问题是匿名类实例内部的变量是否可以在运行时解析。只要保证变量在运行时范围内，就不必将变量设置为final。例如，请参见updateStatus()方法内的两个变量_statusMessage和_statusTextView。

public class WorkerService extends Service {

Worker _worker;
ExecutorService _executorService;
ScheduledExecutorService _scheduledStopService;

TextView _statusTextView;


@Override
public void onCreate() {
    _worker = new Worker(this);
    _worker.monitorGpsInBackground();

    // To get a thread pool service containing merely one thread
    _executorService = Executors.newSingleThreadExecutor();

    // schedule something to run in the future
    _scheduledStopService = Executors.newSingleThreadScheduledExecutor();
}

@Override
public int onStartCommand(Intent intent, int flags, int startId) {

    ServiceRunnable runnable = new ServiceRunnable(this, startId);
    _executorService.execute(runnable);

    // the return value tells what the OS should
    // do if this service is killed for resource reasons
    // 1. START_STICKY: the OS restarts the service when resources become
    // available by passing a null intent to onStartCommand
    // 2. START_REDELIVER_INTENT: the OS restarts the service when resources
    // become available by passing the last intent that was passed to the
    // service before it was killed to onStartCommand
    // 3. START_NOT_STICKY: just wait for next call to startService, no
    // auto-restart
    return Service.START_NOT_STICKY;
}

@Override
public void onDestroy() {
    _worker.stopGpsMonitoring();
}

@Override
public IBinder onBind(Intent intent) {
    return null;
}

class ServiceRunnable implements Runnable {

    WorkerService _theService;
    int _startId;
    String _statusMessage;

    public ServiceRunnable(WorkerService theService, int startId) {
        _theService = theService;
        _startId = startId;
    }

    @Override
    public void run() {

        _statusTextView = MyActivity.getActivityStatusView();

        // get most recently available location as a latitude /
        // longtitude
        Location location = _worker.getLocation();
        updateStatus("Starting");

        // convert lat/lng to a human-readable address
        String address = _worker.reverseGeocode(location);
        updateStatus("Reverse geocoding");

        // Write the location and address out to a file
        _worker.save(location, address, "ResponsiveUx.out");
        updateStatus("Done");

        DelayedStopRequest stopRequest = new DelayedStopRequest(_theService, _startId);

        // schedule a stopRequest after 10 seconds
        _theService._scheduledStopService.schedule(stopRequest, 10, TimeUnit.SECONDS);
    }

    void updateStatus(String message) {
        _statusMessage = message;

        if (_statusTextView != null) {
            _statusTextView.post(new Runnable() {

                @Override
                public void run() {
                    _statusTextView.setText(_statusMessage);

                }

            });
        }
    }

}

对我有效的方法是在函数外部定义变量。

就在主函数之前声明即可。

Double price;
public static void main(String []args(){
--------
--------
}

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

你能够使匿名内部类的 lastPrice, priceObject 和 price 字段吗？

为了解决上述问题，不同的编程语言做出了不同的决策。
对于Java，解决方案如本文所示。
对于C#，解决方案是允许副作用并且只能通过引用来捕获。
对于C++11，解决方案是允许程序员做出决策。他们可以选择按值或按引用捕获。如果按值捕获，则不会发生副作用，因为引用的变量实际上是不同的。如果按引用捕获，则可能会发生副作用，但程序员应该意识到这一点。

如果变量不是final的话，会很容易混淆，因为它的更改不会在匿名类中被捕获。

只需将变量'price'和'lastPrice'设置为final即可。

-- 编辑

哎呀，显然，在您的函数中也不能对它们进行赋值。您需要新的局部变量。无论如何，我猜现在有人已经给您提供了更好的答案。