文档章节

匿名内部类的参数为什么必须是final的呢?

rotkNirvana
 rotkNirvana
发布于 2016/07/04 19:06
字数 1306
阅读 31
收藏 0

一个谜团

如果你用过类似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;
        }
    });
}

这段代码对一个字符串的list进行过滤,从中找出长度为4的字符串。看起来很是平常,没什么特别的。

但是,声明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
9
10
11
12
  def tryAccessingLocalVariable {
    var number = 123
    println(number)

    var lambda = () => {
      number = 456
      println(number)
    }

    lambda.apply()
    println(number)
  }

上面的Scala代码是合法的,number变量是声明为var的,不是val(类似于Java中的final)。而且在匿名函数中可以修改number的值。

看来Scala中没有类似的规定

C#中有类似的规定吗?

1
2
3
4
5
6
7
8
9
10
11
12
13
public void tryUsingLambda ()
{
  int number = 123;
  Console.WriteLine (number);

  Action action = () => {
      number = 456;
      Console.WriteLine (number);
  };

  action ();
  Console.WriteLine (number);
}

这段C#代码也是合法的,number这个局部变量在lambda表达式内外都可以访问和赋值。

看来C#中也没有类似的规定

分析谜团

三门语言中只有Java有这种限制,那我们分析一下吧。先来看一下Java中的匿名内部类是如何实现的:

先定义一个接口:

1
2
3
public interface MyInterface {
    void doSomething();
}

然后创建这个接口的匿名子类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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
9
10
11
12
13
14
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);
    }
}

可以看到名为number的局部变量是作为构造方法的参数传入匿名内部类的(以上代码经过了手动修改,真实的反编译结果中有一些不可读的命名)。

如果Java允许匿名内部类访问非final的局部变量的话,那我们就可以在TryUsingAnonymousClass$1中修改paramInteger,但是这不会对number的值有影响,因为它们是不同的reference。

这就会造成数据不同步的问题。

所以,谜团解开了:Java为了避免数据不同步的问题,做出了匿名内部类只可以访问final的局部变量的限制。

但是,新的谜团又出现了:

Scala和C#为什么没有类似的限制呢?它们是如何处理数据同步问题的呢?

上面出现过的那段Scala代码中的lambda表达式会编译成这样:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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;
    }
}

可以看到number也是通过构造方法的参数传入的,但是与Java的不同是这里的number不是直接传入的,是被IntRef包装了一层然后才传入的。对number的值修改也是通过包装类进行的:this.number$2.elem = 456;

这样就保证了lambda表达式内外访问到的是同一个对象。

再来看看C#的处理方式,反编译一下,发现C#编译器生成了如下的一个类:

1
2
3
4
5
6
7
8
9
10
private sealed class <tryUsingLambda>c__AnonStorey0
{
  internal int number;

  internal void <>m__0 ()
  {
      this.number = 456;
      Console.WriteLine (this.number);
  }
}

把number包装在这个类内,这样就保证了lambda表达式内外使用的都是同一个number,即便重新赋值也可以保证内外部的数据是同步的。

小结

Scala和C#的编译器通过把局部变量包装在另一个对象中,来实现lambda表达式内外的数据同步。

而Java的编译器由于未知的原因(怀疑是为了图省事儿?)没有做包装局部变量这件事儿,于是就只好强制用户把局部变量声明为final才能在匿名内部类中使用来避免数据不同步的问题。

© 著作权归作者所有

rotkNirvana
粉丝 2
博文 9
码字总数 5592
作品 0
深圳
程序员
私信 提问
Java中的匿名函数详解

一、使用匿名内部类 匿名内部类由于没有名字,所以它的创建方式有点儿奇怪。创建格式如下: new 父类构造器(参数列表)|实现接口() 在这里我们看到使用匿名内部类我们必须要继承一个父类或...

lwl2014100338的博客
2017/12/20
0
0
java学习笔记--内部类:(参考java核心技术卷1and转载)

做JavaEE即网站的 基本不接触内部类 做安卓的 基本天天接触内部类 内部类是定义在另一个类中的类 可以分为这四类: 局部内部类 成员内部类 与外部类有直接联系 静态内部类 与外部类没有直接联...

codingcoge
2018/04/27
0
0
再次深入final关键字- 匿名类用到的变量为什么一定要是final的呢?

提起变量,大家都是耳熟能详, final成员变量表示常量,只能被赋值一次,赋值后值不再改变。 final类不能被继承,没有子类,final类中的方法默认是final的。 final方法不能被子类的方法覆盖,但...

Anderson大码渣
2017/09/14
0
0
Java中内部类

1.四种内部类:成员内部类、局部内部类、匿名内部类和静态内部类。 2.成员内部类 2.1成员内部类可以无条件访问外部类的所有成员属性和成员方法(包括private成员和静态成员)。 2.2成员内部类...

指尖Coding
2016/09/18
18
0
java基础重点讲解,看了还不会找我(十)

视频下载地址:https://download.csdn.net/download/xxfisgirlgad/10886817、 ###10.01面向对象(package关键字的概述及作用)(了解) A:为什么要有包 将字节码(.class)进行分类存放 包其实就是...

谢小芳是女神
2018/12/30
0
0

没有更多内容

加载失败,请刷新页面

加载更多

GitLab Auto DevOps功能与Kubernetes集成教程

介 绍 在这篇文章中,我们将介绍如何将GitLab的Auto DevOps功能与Rancher管理的Kubernetes集群连接起来,利用Rancher v2.2.0中引入的授权集群端点的功能。通过本文,你将能全面了解GitLab如何...

RancherLabs
15分钟前
3
0
基本类型 引用类型的问题

用concat()拷贝了个数组 ,原数组包含了引用类型, tempAee === this.dynacArr[0][this.dynacArr[1]][0] //false 虽然拷贝了个数组 , tempAee[0] === this.dynacArr[0][this.dynacArr[1]][......

东东笔记
16分钟前
1
0
Linux下Java运行.class文件,报错找不到或无法加载主类

Linux下Java运行.class文件,报错找不到或无法加载主类 classpath配置的错误,所以找不到.class文件。 原先的etc/profile中的classpath配置 export CLASSPATH=$JAVA_HOME/lib/tools.jar 更改...

Mr_Tea伯奕
27分钟前
1
0
vue 日期计算

搞开发少不了对时间进行加减操作,尤其是前端对日期操作不能单纯的加减,不然31+1 变成32号就扯了。比如推算前几分钟、后几分钟,,前几天、后几天,前几月、后几月等等相关操作。 百度找半天...

朝如青丝暮成雪
39分钟前
1
0
非递归实现后序遍历二叉树

问题描述 从键盘接受输入先序序列,以二叉链表作为存储结构,建立二叉树(以先序来建立)并对其进行后序遍历,然后将遍历结果打印输出。要求采用非递归方法实现。 解题思路 Push根结点到第一...

niithub
52分钟前
4
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部