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

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

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

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

lambda-state-final- Brian Goetz

但是，从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
    }
);

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

Lambda表达式可以访问

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

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

此外,

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

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

此外，不要忘记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，字节码都是相同的。

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