编辑:
我需要改变几个变量的值，因为他们通过计时器运行几次。我需要在计时器的每次迭代中不断更新值。我不能将值设置为final，因为这将阻止我更新值，但是我得到了我在下面的初始问题中描述的错误:
我之前写过如下内容:
我得到错误“不能引用在不同方法中定义的内部类中的非最终变量”。
这发生在名为price的double和名为priceObject的price上。你知道我为什么会有这个问题吗?我不明白为什么我要做最后申报。如果你能看到我在做什么，我要怎么做才能解决这个问题。
public static void main(String args[]) {
int period = 2000;
int delay = 2000;
double lastPrice = 0;
Price priceObject = new Price();
double price = 0;
Timer timer = new Timer();
timer.scheduleAtFixedRate(new TimerTask() {
public void run() {
price = priceObject.getNextPrice(lastPrice);
System.out.println();
lastPrice = price;
}
}, delay, period);
}
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);
}
主要的问题是匿名类实例中的变量是否可以在运行时解析。只要保证变量在运行时范围内，就不一定要使变量为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);
}
});
}
}
}
当我偶然发现这个问题时，我只是通过构造函数将对象传递给内部类。如果需要传递原语或不可变对象(如本例)，则需要包装器类。
编辑:实际上，我根本不使用匿名类，而是一个适当的子类:
public class PriceData {
private double lastPrice = 0;
private double price = 0;
public void setlastPrice(double lastPrice) {
this.lastPrice = lastPrice;
}
public double getLastPrice() {
return lastPrice;
}
public void setPrice(double price) {
this.price = price;
}
public double getPrice() {
return price;
}
}
public class PriceTimerTask extends TimerTask {
private PriceData priceData;
private Price priceObject;
public PriceTimerTask(PriceData priceData, Price priceObject) {
this.priceData = priceData;
this.priceObject = priceObject;
}
public void run() {
priceData.setPrice(priceObject.getNextPrice(lastPrice));
System.out.println();
priceData.setLastPrice(priceData.getPrice());
}
}
public static void main(String args[]) {
int period = 2000;
int delay = 2000;
PriceData priceData = new PriceData();
Price priceObject = new Price();
Timer timer = new Timer();
timer.scheduleAtFixedRate(new PriceTimerTask(priceData, priceObject), delay, period);
}
这是另一种解释。考虑下面这个例子
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变量做了什么，因为它们实际上不是变量，它们像常量(一切都发生在编译时，而不是在运行时)。
