相关疑难解决方法(0)

我有一个匿名的内部类和一个等效的lambda.为什么变量初始化规则对lambda更严格,是否有比匿名内部类更清晰的解决方案或在构造函数中初始化它？

import java.util.concurrent.Callable;

public class Immutable {
    private final int val;

    public Immutable(int val) { this.val = val; }

    // Works fine
    private final Callable<String> anonInnerGetValString = new Callable<String>() {    
        @Override
        public String call() throws Exception {
            return String.valueOf(val);
        }
    };

    // Doesn't compile; "Variable 'val' might not have been initialized"
    private final Callable<String> lambdaGetValString = () -> String.valueOf(val);
}

编辑:我确实遇到了一个解决方法:使用getter for val.

我不明白这种行为.

这段代码符合:

public class A {

    private String s;

    private Function<String, String> f = e -> s;

    public A(String s) {
        this.s = s;
    }
}

但是,如果我做s最后的,那么我得到一个编译器错误:

public class A {

    private final String s;

    private Function<String, String> f = e -> s; // Variable 's' might not have been initialized

    public A(String s) {
        this.s = s;
    }
}

这是为什么？如果是另一种方式,我明白了,但是当我声明一个字段final(这迫使我在构造函数中初始化它的值)时,编译器是怎么抱怨的,当它不是时它就可以了final？