Java 内部类：实例、静态、匿名和局部写法

编译后，内部类会生成单独的字节码文件，命名方式通常是 外部类名$内部类名.class。

静态内部类

静态内部类和外部类对象没有绑定关系，所以不需要先创建外部类实例。

它的限制也很明确：不能直接访问外部类的非静态成员，因为它手里没有外部类对象引用。真要用，只能自己 new 一个外部类对象出来。

class OClass {
    private int a = 1;
    public static int b = 2;
    public int c = 3;

    static class IClass {
        public int d = 4;
        public static int e = 5;
        private int f = 6;

        public void test() {
            OClass out = new OClass();
            System.out.println(out.a);
            System.out.println(b);
            System.out.println(out.c);
            System.out.println(d);
            System.out.println(e);
            System.out.println(f);
            System.out.println("IClass::test");
        }
    }

    public void test() {
        System.out.println("OClass::test");
    }
}

public class TestNbl {
    public static void main(String[] args) {
        OClass.IClass a = new OClass.IClass();
        a.test();
    }
}

静态内部类适合放一些和外部类逻辑有关，但又不依赖外部类实例的工具性代码。很多时候，这比把类拆出去更顺手。

匿名内部类

匿名内部类就是不单独声明类名，直接在创建对象的时候顺手把实现写出来。接口实现、回调、一次性逻辑里很常见。

interface IA {
    void test();
}

public class TestNbl {
    public static void main(String[] args) {
        // 第一种方法调用
        // 匿名内部类对象
        IA a = new IA() {
            public void test() {
                System.out.println("重写了接口的方法!");
            }
        };
        a.test();

        // 第二种方法调用
        new IA() {
            public void test() {
                System.out.println("重写了接口的方法!");
            }
        }.test();
    }
}

这种写法短，但也容易把逻辑写散。代码少的时候很省事，复杂一点就不太适合继续堆了。

局部内部类

局部内部类定义在方法内部，只在这个方法的作用域里有效。出了方法，基本就找不到它了。

它有几个限制：不能被 public 和 static 修饰，平时用得也不多。实际开发里，它更多是'可以这么写'，而不是'应该这么写'。

class Outer {
    void test() {
        class Inner {
            void run() {
                System.out.println("Inner::run");
            }
        }
        new Inner().run();
    }
}

局部内部类编译后，字节码文件通常会带上编号，形式类似 外部类名$内部类名$局部内部类序号.class。

小结

内部类这套东西，核心不是语法多，而是边界感：

• 实例内部类依赖外部类对象，适合和实例状态强绑定的场景。
• 静态内部类更独立，适合放不依赖外部实例的辅助逻辑。
• 匿名内部类适合一次性实现，图的是快。
• 局部内部类更偏局部封装，日常开发里出现频率不高。

如果只是为了'看起来高级'去用内部类，通常没必要；真能把作用域收紧、把代码放到更合适的位置，它才算用对了。