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

发布于 2024-08-01 20:34:28 字数 779 浏览 8 评论 0原文

编辑：当多个变量通过计时器运行多次时，我需要更改它们的值。我需要在计时器的每次迭代中不断更新值。我无法将值设置为最终值，因为这会阻止我更新值，但是我收到了我在下面的初始问题中描述的错误：

我之前写过以下内容：

我收到错误“无法引用在不同方法中定义的内部类中的非最终变量”。
这种情况发生在双重调用的价格和称为 PriceObject 的价格上。你知道我为什么会遇到这个问题吗？我不明白为什么我需要最终声明。另外，如果您能看到我正在尝试做什么，我需要做什么来解决这个问题。

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);
}

原文

Edited:
I need to change the values of several variables as they run several times thorugh a timer. I need to keep updating the values with every iteration through the timer. I cannot set the values to final as that will prevent me from updating the values however I am getting the error I describe in the initial question below:

I had previously written what is below:

I am getting the error "cannot refer to a non-final variable inside an inner class defined in a different method".
This is happening for the double called price and the Price called priceObject. Do you know why I get this problem. I do not understand why I need to have a final declaration. Also if you can see what it is I am trying to do, what do I have to do to get around this problem.

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);
}

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

单身狗的梦 2024-08-08 20:34:28

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

编辑 - 请参阅下面的评论 - 正如 KeeperOfTheSoul 指出的那样，以下不是正确的解释。

这就是它不起作用的原因：

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

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

但匿名类对象引用这些变量。如果匿名类对象在变量被清理后尝试访问变量，事情就会变得非常错误。

通过将 lastPrice 和 price 设置为 final，它们不再是真正的变量，而是常量。然后，编译器可以将匿名类中 lastPrice 和 price 的使用替换为常量的值（当然，在编译时），并且您不会不再有访问不存在的变量的问题。

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

@Ankur：你可以这样做：

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 doesn't support true closures, even though using an anonymous class like you are using here (new TimerTask() { ... }) looks like a kind of closure.

edit - See the comments below - the following is not a correct explanation, as KeeperOfTheSoul points out.

This is why it doesn't work:

The variables lastPrice and price are local variables in the main() method. The object that you create with the anonymous class might last until after the main() method returns.

When the main() method returns, local variables (such as lastPrice and price) will be cleaned up from the stack, so they won't exist anymore after main() returns.

But the anonymous class object references these variables. Things would go horribly wrong if the anonymous class object tries to access the variables after they have been cleaned up.

By making lastPrice and price final, they are not really variables anymore, but constants. The compiler can then just replace the use of lastPrice and price in the anonymous class with the values of the constants (at compile time, of course), and you won't have the problem with accessing non-existent variables anymore.

Other programming languages that do support closures do it by treating those variables specially - by making sure they don't get destroyed when the method ends, so that the closure can still access the variables.

@Ankur: You could do this:

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);      
}

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

如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

评论（20）

关于作者

相关话题

热门标签

推荐作者

╭⌒浅淡时光〆

慕巷

浅生活

bal

lqwuliang

后来的我们

友情链接

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。