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

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

．.． 从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

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 int number;
number = 23;

有效的最后:

int number;
number = 34;

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

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

Lambda表达式可以访问

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

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

此外,

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

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

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