．.． 从Java SE 8开始，局部类可以访问封闭块的final或有效final的局部变量和参数。在初始化后值从未改变的变量或参数实际上是final。

例如，假设变量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编译器生成一个类似于“内部类引用的局部变量必须是final或有效的final”的错误消息，其中内部类PhoneNumber试图访问numberLength变量:

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

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

根据文件:

在初始化后值从未改变的变量或参数实际上是final。

基本上，如果编译器发现一个变量在初始化之外没有出现在赋值中，则认为该变量实际上是final变量。

例如，考虑一些类:

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

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; 

        }
    }    
}

正如其他人所说，在初始化后值从未改变的变量或参数实际上是final的。在上面的代码中，如果你在内部类FirstLevel中改变了x的值，那么编译器会给你一个错误消息:

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

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

但是，从Java SE 8开始，局部类可以访问>外围块的局部变量和参数，这些变量和参数是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
    }
);

When a lambda expression uses an assigned local variable from its enclosing space there is an important restriction. A lambda expression may only use local variable whose value doesn't change. That restriction is referred as "variable capture" which is described as; lambda expression capture values, not variables. The local variables that a lambda expression may use are known as "effectively final". An effectively final variable is one whose value does not change after it is first assigned. There is no need to explicitly declare such a variable as final, although doing so would not be an error. Let's see it with an example, we have a local variable i which is initialized with the value 7, with in the lambda expression we are trying to change that value by assigning a new value to i. This will result in compiler error - "Local variable i defined in an enclosing scope must be final or effectively final"

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

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

在“Brian Goetz”的一篇文章中，

非正式地说，如果局部变量的初始值从未改变，那么它实际上就是final变量——换句话说，声明它为final不会导致编译失败。

lambda-state-final- Brian Goetz

当一个变量被初始化一次并且在其所有者类中从未发生变化时，它就是最终的或有效的最终的。我们不能在循环或内部类中初始化它。

最后:

final int number;
number = 23;

有效的最后:

int number;
number = 34;

注意:Final和Effective Final是相似的(赋值后它们的值不会改变)，但只是有效的Final变量 没有使用关键字final声明。

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

final int variable = 123;

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

int variable = 123;
variable = 456;

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

int variable = 123;

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

如果可以将最后一个修饰符添加到局部变量，那么就是 有效的决赛。

Lambda表达式可以访问

静态变量, 实例变量, 有效的最终 方法参数，以及 有效的最终 局部变量。

来源:OCP: Oracle认证专业Java SE 8程序员II学习指南，Jeanne Boyarsky, Scott Selikoff

此外,

有效最终变量是一个值为never的变量 更改了，但没有使用final关键字声明。

来源:从Java开始:从控制结构到对象(第6版)，Tony Gaddis

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

有效的最后一个主题在JLS 4.12.4中进行了描述，最后一段包含了明确的解释:

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

Final是一个用关键字Final声明的变量，示例:

final double pi = 3.14 ;

它在整个程序中都是最终的，在这一行之后改变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
            }
        }   
   }    
}

将变量声明为final或不声明为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 Bit上的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为真，不会改变它的状态。因此这段代码是不可达的(在这个答案中有更多内容)。出于同样的原因，第9行的代码也会出错。i的状态不需要求值，因为它是确定的。

另一方面，虽然变量j实际上是final，但它的处理方式不同。没有应用这样的优化。j的状态被求值两次。不管j是否有效为final，字节码都是相同的。

effective final变量是一个局部变量，即:

未定义为最终 只分配一次。

final变量是这样的变量:

用final关键字声明。