根据文件:

在初始化后值从未改变的变量或参数实际上是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;
    }
}

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

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

如果变量实际上是final，在其声明中添加final修饰符将不会引入任何编译时错误。相反，在有效程序中声明为final的局部变量或参数，如果final修饰符被移除，则变为有效的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，字节码都是相同的。

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

Lambda表达式可以访问

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

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

此外,

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

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

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