有效的最终/最终限制不是无用的吗？ [复制]

Question

我不明白为什么 java 语言的实现者会这样做，以便在 lambda 中使用并从函数范围传递的变量必须是最终的。

我反编译了这段代码：

public class Main {
    @FunctionalInterface
    interface Test {
        void method(int t);
    }

    static void test(Test t) {
        t.method(3);
    }

    public static void main(String... args) {
        int a = 3;
        test((i)-> {
            System.out.println(a + i);
        });
    }
}

编译器所做的就是复制该变量，就好像它是通过构造函数传递的一样。我有这 3 个课程：

1：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

import Main.1;
import Main.Test;

public class Main {
    public Main() {
    }

    static void test(Test var0) {
        var0.method(3);
    }

    public static void main(String... var0) {
        byte var1 = 3;
        test(new 1(var1));
    }
}

2：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

import Main.Test;

final class Main$1 implements Test {
    Main$1(int var1) {
        this.val$a = var1;
    }

    public void method(int var1) {
        System.out.println(this.val$a + var1);
    }
}

3：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

@FunctionalInterface
interface Main$Test {
    void method(int var1);
}

为什么实现者不能只复制变量而不管它是否被修改，所以我们可以这样做：

public class Main {
    @FunctionalInterface
    interface Test {
        void method(int t);
    }

    static void test(Test t) {
        t.method(3);
    }

    public static void main(String... args) {
        int a = 3;
        test((i)-> {
            a += 1; // allow modification, a is copied anyway, why not?
            System.out.println(a + i);
        });
    }
}

Answer 1

这没有技术原因。只是如果您允许在 lambda 中使用非最终字段，那么您可以编写看起来不错但实际上不起作用的代码。

例如：

void printSum(Collection<Integer> numbers) {
  int sum = 0;
  numbers.forEach(i -> sum += i);
  System.out.println(sum);
}

目前编译器不允许您这样做，因为您无法访问 lambda 中的非最终 sum。正如您所指出的，变量无论如何都会被复制到 lambda 中，所以它可以允许这样做。

如果是这样，那么这段代码会编译，但总是打印 0，因为只有 lambda 中的 sum-copy 被修改，而不是“真实的”。

只允许引用“有效最终”变量是一个很好的折衷方案，它不需要在任何地方都使用 final 关键字，同时仍然避免这样的误解。