Java 中的匿名内部类是如何实现的?

Java

先定义一个接口:

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.doSomegthing();
        System.out.println(number);
    }
}

这个匿名子类会被编译成一个单独的类,反编译的结果是这样的:

// 匿名内部类的反编译结果
class TryUsingAnonymousClass$1
implements MyInterface{
    private final TryUsingAnonymousClass this$0;
    private fianl Integer paramInteger;
    TryUsingAnonymousClass$1(TryUsingAnonymousClass this$0,Integer paramInteger){
        this.this$0 = this$0;8| this.paramInteger = paramInteger;
    }
    public void doSomething(){
        System.out.println(this.paramInteger);
    }
}

可以看到外部类和名为 number 的局部变量是作为构造方法的参数传入匿名内部类的

为什么局部变量要作为内部类构造方法的参数传入?

为了解决:局部变量的生命周期与局部内部类的对象的生命周期不一致的问题
a. 问题:设方法 useMyInterface 被调用,从而在它的调用栈中生成了变量 number ,此时产生了一个局部内部类对象 myInterface ,它访问了该局部变量 number.当方法 useMyInterface 运行结束后,局部变量 number 就已经死亡了,不存在了.但是局部内部类对象 myInterface 还可能一直存在(只能没有人在引用该对象时,它才会死亡),它不会随着方法 useMyInterface 运行结束死亡,这是出现了一个荒唐的"结果":局部内部类对象 myInterface 要访问一个已不存在的局部变量 number

b. 解决方法: 通过讲局部变量 "复制" 一份,复制品直接作为局部内部类的数据成员.这样:当局部内部类访问局部变量时,其实真正访问的是这个局部变量的"复制品"(即:这个复制品就代表了那个局部变量).因此:当运行栈中的局部变量死亡时,局部内部类对象仍可以访问局部变量(其实访问的是复制品),给人的感觉:好像是局部变量的"生命期"延长了.

c. 为什么会与 fianl 有关系?
为了保证局部变量和内部类中的复制品的数据一致性
若是 基本数据类型,当变量是 final 时,由于其值不变,因而:其复制品与原始的量是一样的.语义效果相同.
若:不是 final ,就无法保证:复制品语原始变量保持一致了,因为:在方法中改的是原始变量,而局部内部类中改的是复制品.若是引用类型,当变量是 final 时,由于其引用值不变(即:永远指向同一个对象),因而:其复制品与原始的引用变量一样,永远指向同一个对象(由于是 final ,从而保证:只能指向这个对象,再不能指向其他),达到:局部内部类中访问的复制品与方法代码中的原始对象,永远都是同一个即:语义效果是一样的.否则:当方法中原始变量,而局部内部类中改复制品时,就无法保证:复制品与原始变量保持一致了(因此:它们原本就应该是同一个变量.)

例子

现在我们来看,如果我要实现一个在一个方法中匿名调用 ABCClass 的例子:

public static void test(final String str){
    // 或 final String str = "axman";
    ABSClass c = new ABCClass(){
        public void  m(){
            int x = s.hashCode();
            System.out.println(x);
        }
    }
    //其他代码
}

从代码上看,在一个方法内部定义的内部类的方法访问外部方法内局部变量或方法参数,是非常自然的的事,但内部类变异的时候如何获取这个变量,因为内部类除了它的生命周期实在方法内部,其他的方面它就是一个普通类.那么它外面的那个局部变量或方法参数怎么被内部类访问?编译器在实现时实际上是这样的:

public static void test(final String s){
    //  或  final String s = "axman";
    class OuterClass$1 extends ABSClass {
        private final String s;
        public OuterClass$1(String s){
            this.s = s;
        }
        public void m(){
            int x = s.hashCode();
            System.out.println(x);
        }
    }
};
ABSClass c = new OuterClass$1(s);
// 其他代码

即外部类的变量作为构造方法的参数传给了内部类的私有成员.
假如没有 final , 那么:

public static void test(String s){
    // 或 String s = "axman";
    ABSClass c = new ABSClass(){
        public void m(){
            s = "other";
        }
    };
    System.out.println(s);
}

就会编译成:

public static void test(String s){
    // 或 String s = "axman";
    class OuterClass$1 extends ABSClass{
        private String s;
        public OuterClass$1(String s){
            this.s = s;
        }
        public void m(){
            s = "other";
        }
    };
    ABSClass c = new OuterClass$1(s);
}

内部类的 s 重新指向 "other" 并不影响 test 的参数或外部定义的那个 s.同理如果外部的 s 重新复制内部类的 s 也不会跟着改变.
而你看到的

public static void test(String s){
    // 或 Stirng s = "axman";
    ABSClass c = new ABSClass(){
        public void m(){
            s = "other";
        }
    };
    System.out.prinln(s);
}

在语法上是一个 s ,在内部类中被改变了,但结果打印出来的你认为是同一的 s 却还是原来的 "axman",你能接受这样的结果吗?
所以final 从语法上约束类实际上这两个不同变量的一致性(表现为同一常量)

jdk1.8版本下的新变化

1.8以后,并非不用是 final 的,而是在编译期间要求值不发生变化.在你的代码中,如果 user 的值发生变化,就会出错.
编译如下代码:

public class TestFinal{
    // 这样代码就不能通过编译了
    //这里不用 final User user,但是 user 不能改变
    public void test(User user){
        user = new User();//user 变化了,所以报错
        user.setName("zhaoyang");
        (new Thread(){
            public void run(){
                System.out.println("user.name--->"+user.name);// 报错
            }
        }
        ).start();
    }
    public static void main(String[] args){
        User user = new User();
        user.setId(007);
        user.setName("zhaoyang");
        TestFinal testFinal = new TestFinal();
        testFinal.test(user);
    }
}

总结:由于局部内部类的生命周期和局部变量的生命周期不相同,导致局部内部类在使用局部变量时需要在局部内部类中新建一份副本,而为了保证在方法内局部变量和内部类中它的副本的一致性,需要将该变量声明为 final 常量.