最终和有效最终之间的区别

Question

我正在使用 Java 8 中的 lambda，我遇到了警告 local variables referenced from a lambda expression must be final or effectively final。我知道当我在匿名类中使用变量时，它们在外部类中必须是最终的，但是 - final 和 有效地最终 之间有什么区别？

Answer 1

... 从 Java SE 8 开始，本地类可以访问最终或有效最终的封闭块的局部变量和参数。 一个变量或参数，其值在初始化后永远不会改变，它实际上是最终的。

例如，假设变量numberLength没有声明为final，而你在PhoneNumber构造函数中添加了标记的赋值语句：

public class OutterClass {  

  int numberLength; // <== not *final*

  class PhoneNumber {

    PhoneNumber(String phoneNumber) {
        numberLength = 7;   // <== assignment to numberLength
        String currentNumber = phoneNumber.replaceAll(
            regularExpression, "");
        if (currentNumber.length() == numberLength)
            formattedPhoneNumber = currentNumber;
        else
            formattedPhoneNumber = null;
     }

  ...

  }

...

}

由于这个赋值语句，变量 numberLength 不再是有效的 final。 因此，Java 编译器生成类似于“从内部类引用的局部变量必须是最终或有效最终”的错误消息，其中内部类 PhoneNumber 尝试访问 numberLength 变量：

http://codeinventions.blogspot.in/2014/07/difference-between-final-and.html

http://docs.oracle.com/javase/tutorial/java/javaOO/localclasses.html

Answer 2

我发现解释“有效最终”的最简单方法是想象将final 修饰符添加到变量声明中。如果通过此更改，程序在编译时和运行时继续以相同的方式运行，则该变量实际上是最终变量。

Answer 3

根据docs：

一个变量或参数，其值在初始化后从不改变是有效的。

基本上，如果编译器发现一个变量没有出现在其初始化之外的赋值中，那么该变量被认为是实际上是最终的。

例如，考虑一些类：

public class Foo {

    public void baz(int bar) {
        // While the next line is commented, bar is effectively final
        // and while it is uncommented, the assignment means it is not
        // effectively final.

        // bar = 2;
    }
}

Answer 4

下面这个变量是final，所以一旦初始化我们就不能改变它的值。如果我们尝试这样做，我们会得到一个编译错误...

final int variable = 123;

但是如果我们像这样创建一个变量，我们可以改变它的值...

int variable = 123;
variable = 456;

但在 Java 8 中，所有变量默认为 final。但是代码中第二行的存在使得它非最终。因此，如果我们从上面的代码中删除第二行，我们的变量现在是“有效地最终”...

int variable = 123;

所以.. 任何分配一次且仅一次的变量都是“有效最终的”。

Answer 5

'Effectively final' 是一个变量，如果它被 'final' 附加，则不会产生编译器错误

来自“Brian Goetz”的一篇文章，

通俗地说，如果一个局部变量的初始值从不改变，那么它实际上就是最终变量——换句话说，将它声明为最终变量不会导致编译失败。

lambda-state-final- Brian Goetz

Answer 6

一个变量是final或实际上是final当它被初始化一次并且它在它的所有者类中永远不会变异 .而且我们不能在循环或内部类中初始化它。

决赛：

final int number;
number = 23;

最终有效：

int number;
number = 34;

注意：Final和Effective Final是相似的（赋值后它们的值不会改变）但只是有效的Final变量 未使用关键字final 声明。

Answer 7

当 lambda 表达式使用从其封闭空间分配的局部变量时，有一个重要的限制。 lambda 表达式只能使用值不变的局部变量。该限制被称为“variable capture”，描述为： lambda 表达式捕获值，而不是变量。
lambda 表达式可能使用的局部变量称为“有效最终”。
一个有效的最终变量是其值在首次分配后不会改变的变量。没有必要将这样的变量显式声明为 final，尽管这样做不会出错。
让我们看一个例子，我们有一个局部变量 i，它的初始化值为 7，在 lambda 表达式中，我们试图通过为 i 分配一个新值来更改该值。这将导致编译器错误 - “我在封闭范围内定义的局部变量必须是最终的或有效的最终”

@FunctionalInterface
interface IFuncInt {
    int func(int num1, int num2);
    public String toString();
}

public class LambdaVarDemo {

    public static void main(String[] args){             
        int i = 7;
        IFuncInt funcInt = (num1, num2) -> {
            i = num1 + num2;
            return i;
        };
    }   
}

Answer 8

Effective final 主题在JLS 4.12.4 中描述，最后一段包含清晰的解释：

如果一个变量实际上是 final 的，将 final 修饰符添加到它的声明中不会引入任何编译时错误。相反，在有效程序中声明为 final 的局部变量或参数如果删除 final 修饰符，则变为有效的 final。

Answer 9

final 是用关键字final 声明的变量，例如：

final double pi = 3.14 ;

在整个程序中它仍然是final，永远不允许在此行之后更改 pi。

实际上是最终的：任何局部变量或参数，现在只赋值一次（或只更新一次）。它可能不会在整个计划中保持有效的最终效果。因此这意味着 有效最终 变量可能会在立即分配/更新至少一个分配后立即失去其有效最终属性。示例：

class EffectivelyFinal {
    
    public static void main(String[] args) {
        calculate(124,53);
    }
    
    public static void calculate( int operand1, int operand2){   
     int rem = 0;  //   operand1, operand2 and rem are effectively final here
     rem = operand1%2  // rem lost its effectively final property here because it gets its second assignment 
                       // operand1, operand2 are still effectively final here 
        class operators{

            void setNum(){
                operand1 =   operand2%2;  // operand1 lost its effectively final property here because it gets its second assignment
            }
            
            int add(){
                return rem + operand2;  // does not compile because rem is not effectively final
            }
            int multiply(){
                return rem * operand1;  // does not compile because both rem and operand1 are not effectively final
            }
        }   
   }    
}

Answer 10

public class LambdaScopeTest {
    public int x = 0;        
    class FirstLevel {
        public int x = 1;    
        void methodInFirstLevel(int x) {

            // The following statement causes the compiler to generate
            // the error "local variables referenced from a lambda expression
            // must be final or effectively final" in statement A:
            //
            // x = 99; 

        }
    }    
}

正如其他人所说，一个变量或参数在初始化后其值永远不会改变，它实际上是最终的。在上面的代码中，如果你改变了内部类FirstLevel中x的值，那么编译器会给你错误信息：

从 lambda 表达式引用的局部变量必须是 final 或有效 final。

Answer 11

如果您可以将 final 修饰符添加到局部变量，它是 实际上是最终的。

Lambda 表达式可以访问

• 静态变量，

• 实例变量，

• 实际上是最终的 方法参数和

• 实际上是最终的 局部变量。

来源：OCP: Oracle Certified Professional Java SE 8 Programmer II Study Guide, Jeanne Boyarsky, Scott Selikoff

另外，

effectively final 变量是一个变量，其值从不 已更改，但未使用 final 关键字声明。

来源：Starting Out with Java: From Control Structures through Objects (6th Edition), Tony Gaddis

另外，不要忘记final的含义，它在第一次使用之前被初始化了一次。

Answer 12

声明一个变量final 或不声明它final，但保持它有效地最终可能会导致（取决于编译器）不同的字节码。

我们来看一个小例子：

    public static void main(String[] args) {
        final boolean i = true;   // 6  // final by declaration
        boolean j = true;         // 7  // effectively final

        if (i) {                  // 9
            System.out.println(i);// 10
        }
        if (!i) {                 // 12
            System.out.println(i);// 13
        }
        if (j) {                  // 15
            System.out.println(j);// 16
        }
        if (!j) {                 // 18
            System.out.println(j);// 19
        }
    }

main方法对应的字节码（Windows 64位上的Java 8u161）：

  public static void main(java.lang.String[]);
    Code:
       0: iconst_1
       1: istore_1
       2: iconst_1
       3: istore_2
       4: getstatic     #16                 // Field java/lang/System.out:Ljava/io/PrintStream;
       7: iconst_1
       8: invokevirtual #22                 // Method java/io/PrintStream.println:(Z)V
      11: iload_2
      12: ifeq          22
      15: getstatic     #16                 // Field java/lang/System.out:Ljava/io/PrintStream;
      18: iload_2
      19: invokevirtual #22                 // Method java/io/PrintStream.println:(Z)V
      22: iload_2
      23: ifne          33
      26: getstatic     #16                 // Field java/lang/System.out:Ljava/io/PrintStream;
      29: iload_2
      30: invokevirtual #22                 // Method java/io/PrintStream.println:(Z)V
      33: return

对应的行号表：

 LineNumberTable:
   line 6: 0
   line 7: 2
   line 10: 4
   line 15: 11
   line 16: 15
   line 18: 22
   line 19: 26
   line 21: 33

正如我们在12、13、14 行看到的源代码并没有出现在字节码中。那是因为 i 是 true 并且不会改变它的状态。因此，这段代码是无法访问的（更多在这个answer）。出于同样的原因，9 行的代码也丢失了。 i 的状态不必评估，因为它肯定是 true。

另一方面，虽然变量j 实际上是最终的，但它的处理方式不同。没有应用此类优化。 j 的状态被评估两次。无论j 是实际上是最终的，字节码都是相同的。

Answer 13

Effectly final 变量是一个局部变量，即：

1. 未定义为final
2. 仅分配一次。

虽然最终变量是一个变量：

1. 使用 final 关键字声明。

Answer 14

但是，从 Java SE 8 开始，本地类可以访问 >enclosure 块的本地变量和参数，它们是 final 或实际上是 final。

这不是从 Java 8 开始的，我用了很久。 此代码使用（在 java 8 之前）是合法的：

String str = ""; //<-- not accesible from anonymous classes implementation
final String strFin = ""; //<-- accesible 
button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
         String ann = str; // <---- error, must be final (IDE's gives the hint);
         String ann = strFin; // <---- legal;
         String str = "legal statement on java 7,"
                +"Java 8 doesn't allow this, it thinks that I'm trying to use the str declared before the anonymous impl."; 
         //we are forced to use another name than str
    }
);