Java内部类访问外部对象为什么必须是final的呢?
2016-08-16 15:12
330 查看
为什么必须是final的呢?
一个谜团
如果你用过类似guava这种“伪函数式编程”风格的library的话,那下面这种风格的代码对你来说应该不陌生:1 2 3 4 5 6 7 8 9 | public void tryUsingGuava() { final int expectedLength = 4; Iterables.filter(Lists.newArrayList("123", "1234"), new Predicate<String>() { @Override public boolean apply(String str) { return str.length() == expectedLength; } }); } |
但是,声明expectedLength时用的那个final看起来有点扎眼,把它去掉试试:
error: local variable expectedLength is accessed from within inner class; needs to be declared final
结果Java编译器给出了如上的错误,看起来匿名内部类只能够访问final的局部变量。但是,为什么呢?其他的语言也有类似的规定吗?
在开始用其他语言做实验之前我们先把问题简化一下,不要再带着guava了,我们去除掉噪音,把问题归结为:
为什么Java中的匿名内部类只可以访问final的局部变量呢?其他语言中的匿名函数也有类似的限制吗?
Scala中有类似的规定吗?
1 2 3 4 5 6 7 8 910 | def tryAccessingLocalVariable { var number = 123 println(number) var lambda = () => { number = 456 println(number) } lambda.apply() println(number) } |
看来Scala中没有类似的规定。
C#中有类似的规定吗?
1 2 3 4 5 6 7 8 910 | public void tryUsingLambda () { int number = 123; Console.WriteLine (number); Action action = () => { number = 456; Console.WriteLine (number); }; action (); Console.WriteLine (number); } |
看来C#中也没有类似的规定。
分析谜团
三门语言中只有Java有这种限制,那我们分析一下吧。先来看一下Java中的匿名内部类是如何实现的:先定义一个接口:
1 2 3 | public interface MyInterface { void doSomething(); } |
1 2 3 4 5 6 7 8 910 | public class TryUsingAnonymousClass { public void useMyInterface() { final Integer number = 123; System.out.println(number); MyInterface myInterface = new MyInterface() { @Override public void doSomething() { System.out.println(number); } }; myInterface.doSomething(); System.out.println(number); } } |
1 2 3 4 5 6 7 8 910 | class TryUsingAnonymousClass$1 implements MyInterface { private final TryUsingAnonymousClass this$0; private final Integer paramInteger; TryUsingAnonymousClass$1(TryUsingAnonymousClass this$0, Integer paramInteger) { this.this$0 = this$0; this.paramInteger = paramInteger; } public void doSomething() { System.out.println(this.paramInteger); } } |
如果Java允许匿名内部类访问非final的局部变量的话,那我们就可以在TryUsingAnonymousClass$1中修改paramInteger,但是这不会对number的值有影响,因为它们是不同的reference。
这就会造成数据不同步的问题。
所以,谜团解开了:Java为了避免数据不同步的问题,做出了匿名内部类只可以访问final的局部变量的限制。
但是,新的谜团又出现了:
Scala和C#为什么没有类似的限制呢?它们是如何处理数据同步问题的呢?
上面出现过的那段Scala代码中的lambda表达式会编译成这样:1 2 3 4 5 6 7 8 910 | public final class TryUsingAnonymousClassInScala$$anonfun$1 extends AbstractFunction0.mcV.sp implements Serializable { public static final long serialVersionUID = 0L; private final IntRef number$2; public final void apply() { apply$mcV$sp(); } public void apply$mcV$sp() { this.number$2.elem = 456; Predef..MODULE$.println(BoxesRunTime.boxToInteger(this.number$2.elem)); } public TryUsingAnonymousClassInScala$$anonfun$1(TryUsingAnonymousClassInScala $outer, IntRef number$2) { this.number$2 = number$2; } } |
这样就保证了lambda表达式内外访问到的是同一个对象。
再来看看C#的处理方式,反编译一下,发现C#编译器生成了如下的一个类:
1 2 3 4 5 6 7 8 910 | private sealed class <tryUsingLambda>c__AnonStorey0 { internal int number; internal void <>m__0 () { this.number = 456; Console.WriteLine (this.number); } } |
小结
Scala和C#的编译器通过把局部变量包装在另一个对象中,来实现lambda表达式内外的数据同步。而Java的编译器由于未知的原因(怀疑是为了图省事儿?)没有做包装局部变量这件事儿,于是就只好强制用户把局部变量声明为final才能在匿名内部类中使用来避免数据不同步的问题。
相关文章推荐
- 为什么一个匿名内部类使用一个在其外部定的对象必须使用final修饰
- 为什么java内部类访问局部变量必须声明为final?
- 局部内部类访问外部的局部变量时,为什么要求局部变量必须加上final
- Java内部类引用外部类中的局部变量为何必须是final问题解析
- 为什么在内部类中用外部类的对象要用final修饰
- 关于局部内部类访问所在方法的参数或局部变量为什么必须是final的
- 内部类访问局部变量的时候,为什么变量必须加上final修饰
- 为什么局部内部类访问局部变量,局部变量必须声明为final?
- 黑马程序员--Java内部类引用外部类中的局部变量为何必须是final问题解析
- 为什么匿名内部类访问当前方法的局部变量必须为final类型
- Java内部类引用外部类中的局部变量为何必须是final问题解析
- 为什么无法从外部访问VSTO对象?
- Java内部类引用外部类中的局部变量为何必须是final问题解析
- 匿名内部类访问外部类中的局部变量必须是final属性
- 匿名内部类访问外部类中的局部变量必须是final属性
- 为什么内部类访问的外部变量需要使用final修饰
- 【面试对宝典40题的解释】匿名内部类访问外部类中的局部变量必须是final属性
- 匿名内部类访问外部类中的局部变量必须是final属性
- 匿名内部类使用了一个在其外部定义的对象,为什么编译器会要求其参数引用是final呢
- 为什么内部类调用外部变量,外部变量必须用final修饰