匿名内部类是什么？为什么其访问外部变量必须是finally的？

最新推荐文章于 2023-03-10 00:13:39 发布

转载最新推荐文章于 2023-03-10 00:13:39 发布 · 488 阅读

JavaSE 专栏收录该内容

17 篇文章

订阅专栏

本文深入探讨了Java中匿名内部类的使用方法，包括如何利用匿名内部类创建线程及初始化HashMap，同时解析了匿名内部类如何重写方法、调用方法，并通过反编译实例进一步解释了匿名内部类的工作原理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

先来看看使用匿名内部类创建线程和初始化HashMap的示例代码：

使用匿名内部类创建线程：

new Thread() {
public void run() {
System.out.println(“匿名内部类创建线程并启动”);
}

}.start();

使用局部内部类初始化HashMap：

Map map = new HashMap(){
{
put(“name”, “张三”);
put(“age”, “24”);
put(“sex”, “man”);
}
};
System.out.println(map.get(“name”));
//注意如果从外部引用变量的话，put的value必须是不可变的或者为final的。整个匿名函数相当于一个回调方法，必须确保在执行花括号中的语句时，外界局部变量必须存在，而不能被GC回收。
对上面的结构进行解释：

1、创建匿名内部类并实例化对象
new Thread()和new HashMap()都是创建实例对象的过程，而后面跟的花括号代表的是匿名内部类，new Thread(){}、new HashMap(){}，完整的解释应该是用后面的花括号声明了一个匿名内部类，然后通过new关键字创建了该匿名内部类的一个实例对象。
完全可以为一个接口声明一个匿名内部类并创建实例对象，比如：
public interface Inp {
public void sayHello();
}
//创建当前接口的匿名内部类，并实例化对象
Inp inp = new Inp(){

//接口的匿名内部类也是接口的实现类，所以必须实现接口方法
public void sayHello() {
    System.out.println("匿名内部类实现父类接口");
}

}

inp.sayHello();
2、匿名内部类重写方法、调用方法
在1中已经知道new Thread(){}、new HashMap(){}后面的花括号代表的是声明匿名内部类，既然是类，那么里面就可以自定义方法(如HashMap初始化)、实现接口方法(如实现的sayHello()方法)、重写父类方法(如创建线程的run()方法)等
对于后面两种比较容易理解，对于自定义方法(如HashMap初始化)是不是有些晕，初始化HashMap其实并没有自定义方法，而是通过里面的花括号定义了一个实例初始化块，实例初始化块在内部类被实例化过程中自动被调用，实现了HashMap实例化时初始化数据，当然完全可以在里面自定义一个方法，如：
new HashMap(){

//匿名内部类自定义的实例方法
public void sayHi(){
    System.out.println("HashMap sayHi");
}

}.sayHi();
注意：匿名内部类自定义的实例方法是属于匿名内部类实例的，也就是说sayHi()方法不属于HashMap以及Map，所以无法用Map map = new HashMap(){ sayHi() };map.sayHi();方式赋值给Map变量进行调用
那里面调用的put()方法是怎么回事？put()方法属于HashMap的实例方法，在实例初始化块中当然可以被调用了。

内部类里面使用外部类的局部变量时，其实就是内部类的对象在使用它，内部类对象生命周期中都可能调用它，而内部类试图访问外部方法中的局部变量时，外部方法的局部变量很可能已经不存在了，那么就得延续其生命，拷贝到内部类中，而拷贝会带来不一致性，从而需要使用final声明保证一致性。说白了，内部类会自动拷贝外部变量的引用，为了避免：1. 外部方法修改引用，而导致内部类得到的引用值不一致 2.内部类修改引用，而导致外部方法的参数值在修改前和修改后不一致。于是就用 final 来让该引用不可改变。
内部类通常都含有回调，引用那个匿名内部类的函数执行完了就没了，所以内部类中引用外面的局部变量需要是final的，这样在回调的时候才能找到那个变量，而如果是外围类的成员变量就不需要是final的，因为内部类本身都会含有一个外围了的引用（外围类.this），所以回调的时候一定可以访问到。例如：

private Animator createAnimatorView(final View view, final int position) {
MyAnimator animator = new MyAnimator();
animator.addListener(new AnimatorListener() {
@Override
public void onAnimationEnd(Animator arg0) {
Log.d(TAG, “position=” + position);
}
});
return animator;
}

内部类回调里访问position的时候createAnimatorView()早就执行完了，position如果不是final的，回调的时候肯定就无法拿到它的值了，因为局部变量在函数执行完了以后就被回收了。
3. 我们反编译看一下，首先定义接口和匿名内部类：

public interface MyInterface {
void doSomething();
}

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

}

我们进行反编译，结果是：

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。
这就会造成数据不同步的问题。