对匿名内部类的“内部”的理解

老规矩先上代码

package com.xhh.fourstudent;

public class WindBoy {
    public void q(){
        System.out.println("windBoy");
    }
    class Inner{

    }
}

package com.xhh.fourstudent;

public class Main {
    public static void main(String[] args) {
        //匿名内部类 ：是内部类的简化写法。它的本质是一个 带具体实现的 父类或者父接口的 匿名的 子类对象。
        WindBoy a = new WindBoy() {
            @Override
            public void q() {
                System.out.println("斩钢闪");
            }
        };//匿名内部类的对象 该对象是WindBoy的子类对象，但是该子类是匿名类
        new WindBoy() {
            @Override
            public void q() {
                System.out.println("斩钢闪");
            }
        };//匿名内部类的匿名对象
        System.out.println(a.getClass().getName());
        System.out.println(new WindBoy().getClass().getName());//WindBoy的匿名对象
        System.out.println(new WindBoy().new Inner().getClass().getName());//内部类的匿名对象
        a.q();
        new WindBoy().q();
    }
}

输出结果：

com.xhh.fourstudent.Main$1
com.xhh.fourstudent.WindBoy
com.xhh.fourstudent.WindBoy$Inner
斩钢闪
windBoy

再说说理解

之前的不理解主要集中于“内部”二字。
是一个匿名类，这个比较好理解，就是定义了一个类，这个类只用这一次，是一个匿名的类，跟匿名对象一样的逻辑。
至于为什么是内部类，之前一直以为是这个父类的内部类，所以一直不能理解。从上面打印的1行和3行可以看出，内部类的类名特点就是：外部类$内部类。所以明显a是一个内部类。而且是属于Main这个类的内部类。
可以理解为在Main这个类的内部定义了一个WindBoy的子类，但是由于这个类只打算用一次，所以使用匿名的方式。

另外

之前一直理解的匿名内部类，只能是一个抽象类的子类或者接口的实现类，这个理解是不对的。上面这个例子可以看出，匿名内部类还可以是一个正常的类的子类。

扩展：

为什么要使用匿名内部类：

1.当类B仅在类A内使用，匿名内部类可以让外部不知道类B的存在，从而减少代码的维护。
2.类B持有类A，那么B就可以使用A中的变量。

非静态的内部类容易造成内存泄漏：

java是自动垃圾回收，不会发生传统意义上的内存泄漏。我们说的内存泄漏一般是指在java中无意延长了变量的生存周期，比如局部变量的引用放在了静态成员中。
“Java中非静态内部类（匿名内部类也一样）会有宿主类的强引用”，引发的现象是内部类对象方法的生命周期会关联到外部类对象上，延迟外部类对象的回收。
这个强引用（this$0）是编译出来的，是为了维持内部类语法特性的必要代价，无法干预。
想避免这种现象，需要在外部类对象生命周期结束时手动将内部类对象生命周期结束。或者改为静态的内部类。
不过，除非延迟回收会成为系统的运维瓶颈（瞬间产生大量对象导致OOM），一般也不需要特别关注，GC机制通常足以应付。

从编译过后的字节码文件中可以看到，非静态内部类的字节码文件中有一个对于外部类的引用被存在了 this$0 中，也就是说它持有了外部类的对象。那么为什么静态的内部类不会呢？因为它是静态的，所以它引用的外部类的变量也必须是静态对象，这样一来静态变量就会被存放在JVM内存模型的Method Area，从而可以直接引用到需要的变量。
需要注意的是，当以匿名内部类直接实现时，该内部类也默认持有外部类的引用，所以，需要注意内存泄露的问题。