内部类原理

成员内部类

这是源代码，B是内部类，它的test()方法中使用了外部类的filed字段

class A{
    private String filed;
    class B{
        public void test(){
            System.out.println(filed);
        }
    }
}

编译之后的伪代码如下

class A{
    private String filed;
    //编译器补充
    static String filed0(A a){
        return a.filed;
    }
}
class B{
    //编译器补充
    private A a;
    public B(A a){
        this.a = a;
    }
    public void test(){
        System.out.println(A.filed0(a));
    }
}

可以看出：外部类和内部类都有相应的改动

1、在外部类存在一个公用的静态方法，将字段权限暴露出来

2、在内部类创建时，会通过构造器将外部类对象注入到自身成员变量中

3、内部类调用外部类的静态方法，获取到私有属性的值

方法内部类

这是源代码，B是方法内部类，它的testB()方法中使用了外部类testA()方法的filed字段

class A{
    public void testA(String name){
        class B{
            public void testB(){
                System.out.println(name);
            }
        }
        new B().testB();
    }
}

编译之后的伪代码如下：

class A{
    public void testA(String name){
        //编译器注入
        new B(this,name).testB();
    }
}
class B{
    private A a;
    private String name;
    
    //编译器注入
    public B(A a,String name){
        this.a = a;
        this.name = name;
    }
    
    public void testB(){
        System.out.println(name);
    }
}

其内部类的构造器上相对于成员内部类基础上多了局部变量的入参，并将其作为成员变量。

所以为什么方法内部类调用的变量要用final修饰？因为在内部类对象创建时就确定一切了。外面改了，里面可是变不了的

* 内部类中存在指针指向外部类对象，所以当大量使用 new Object(){{}}这样的语法时，要注意是否可能存在内存泄漏的危险