匿名内部类访问局部变量是否需要 final 修饰（Java Kotlin 对比）

1. Java：为什么匿名内部类访问局部变量要使用 final 修饰？

• 对于普通内部类，可以显式的创建对象，通过引用改变外部类变量的值，做到内外变量的同步，故无需 final 修饰该变量

class Outer {
    private int x = 1;
    class Inner {
        private int y = 100;
        public int add() {
            return x + y;
        }
    }
}

• 对于匿名内部类，不能显式的创建对象（也就没有对象引用），不能改变外部类的变量，导致内外变量的不同步，所以给外部变量一个 final 修饰

public class Hello {
	public static void main(String[] args) {
		String str="haha";
		new Thread() {
			@Override
			public void run() {
				System.out.println(str);
			}
		}.start();
	}
}

• JDK1.8 之后做了优化，即不需要将局部变量显示的声明为 final 也不会发生编译错误，实际上 java 底层还是加上了 final
• 那么问题来了，为什么匿名内部类访问局部变量要使用final修饰？
• 这个问题的答案就只有一个：为了保持数据的一致性
• 反编译结果：

public class Hello$1 extends Thread {
	
	private String val$str;
	
	Hello$1(String paramString) {
		this.val$str = paramString;
	}
 
	public void run() {
		System.out.println(this.val$str);
	}
 
}

• 匿名内部类之所以可以访问局部变量，是因为在底层将这个局部变量的值传入到了匿名内部类中，并且以匿名内部类的成员变量的形式存在，这个值的传递过程是通过匿名内部类的构造器完成的
• 这里所说的数据一致性，对引用变量来说是引用地址的一致性，对基本类型来说就是值的一致性
• ++为什么需要用 final 保护数据的一致性呢？++
• 因为将数据拷贝完成后，如果不用 final 修饰，则原先的局部变量可以发生变化。这里到了问题的核心了，如果局部变量发生变化后，匿名内部类是不知道的（因为他只是拷贝了局不变量的值，并不是直接使用的局部变量）。
• 这里举个栗子：原先局部变量指向的是对象 A，在创建匿名内部类后，匿名内部类中的成员变量也指向 A 对象。但过了一段时间局部变量的值指向另外一个 B 对象，但此时匿名内部类中还是指向原先的 A 对象。那么程序再接着运行下去，可能就会导致程序运行的结果与预期不同。

• 参考资料：https://blog.csdn.net/Alphr/article/details/105597019?utm_medium=distribute.pc_relevant.none-task-blog-2

2. kotlin：为什么匿名内部类访问局部变量不需要要使用 final 修饰？

• 其实是个语法糖，底层还是用 final 修饰了的，会被解糖为：

fun main(args: Array<String>) {
    var i = 1
    foo2(object : Inner {
        override fun print() {
            i = 2
            println(i)
        }
    })
    println(i)
}

fun foo2(foo: Inner) {
    foo.print();
}

public static final void main(@NotNull String[] args) {
  final IntRef i = new IntRef();
  i.element = 1;
  foo2((Inner)(new Inner() {
     public void print() {
        i.element = 2;
        int var1 = i.element;
        System.out.println(var1);
     }
  }));
  int var2 = i.element;
  System.out.println(var2);
}

public static final void foo2(@NotNull Inner foo) {
  Intrinsics.checkParameterIsNotNull(foo, "foo");
  foo.print();
}