隐式引用

当一个内部类实例被创建时,它会自动持有一个外部类实例的隐式引用，这个引用使得内部类的代码可以像访问自己的成员一样，自由地访问外部类的成员（包括私有成员）。

这个隐式引用在 Java 编译后会表现为一个名为 this$0（对于非静态内部类）的字段，你可以在反编译后的代码中看到它。

调用规则详解

根据内部类的类型（静态内部类 vs. 非静态内部类），调用外部类变量的规则有所不同。

非静态内部类（最常见）

这是最典型的内部类,它必须依赖于一个外部类的实例才能存在，它可以直接访问外部类的所有成员，包括 private 的。

规则：

• 可以直接访问外部类的实例变量和实例方法。
• 可以直接访问外部类的静态变量和静态方法。
• 访问外部类成员时,如果存在命名冲突（内部类和外部类有同名的变量），可以使用 外部类名.this.成员名 来明确指定。

示例代码：

public class OuterClass {
    // 外部类的实例变量
    private String outerInstanceVariable = "这是外部类的实例变量";
    // 外部类的静态变量
    private static String outerStaticVariable = "这是外部类的静态变量";
    // 外部类的实例方法
    public void outerInstanceMethod() {
        System.out.println("外部类的实例方法被调用了");
    }
    // 外部类的静态方法
    public static void outerStaticMethod() {
        System.out.println("外部类的静态方法被调用了");
    }
    // 定义一个非静态内部类
    class InnerClass {
        // 内部类的实例变量
        private String innerVariable = "这是内部类的变量";
        public void accessOuterMembers() {
            System.out.println("--- 访问外部类的成员 ---");
            // 1. 访问外部类的实例变量
            System.out.println("访问外部类实例变量: " + outerInstanceVariable);
            // 2. 访问外部类的静态变量
            System.out.println("访问外部类静态变量: " + outerStaticVariable);
            // 3. 访问外部类的实例方法
            outerInstanceMethod();
            // 4. 访问外部类的静态方法
            outerStaticMethod();
            // 5. 处理命名冲突
            // 假设外部类也有一个名为 "innerVariable" 的成员
            // String innerVariable = "外部类的同名变量"; 
            // 为了访问外部类的同名成员，必须使用 外部类名.this
            // System.out.println("访问外部类的同名变量: " + OuterClass.this.innerVariable); 
            // 在本例中，我们直接访问内部类的成员
            System.out.println("访问内部类自己的变量: " + this.innerVariable);
        }
    }
    // 外部类的方法，用于创建内部类实例
    public void createInnerInstance() {
        InnerClass inner = new InnerClass();
        inner.accessOuterMembers();
    }
}

如何运行：

public class Main {
    public static void main(String[] args) {
        // 1. 创建外部类实例
        OuterClass outer = new OuterClass();
        // 2. 通过外部类实例创建内部类实例
        // 语法: 外部类实例.new 内部类()
        OuterClass.InnerClass inner = outer.new InnerClass();
        // 3. 调用内部类的方法
        inner.accessOuterMembers();
        // 或者直接在外部类的方法里创建
        System.out.println("\n--- 通过外部类方法调用 ---");
        outer.createInnerInstance();
    }
}

输出结果：

--- 访问外部类的成员 ---
访问外部类实例变量: 这是外部类的实例变量
访问外部类静态变量: 这是外部类的静态变量
外部类的实例方法被调用了
外部类的静态方法被调用了
访问内部类自己的变量: 这是内部类的变量
--- 通过外部类方法调用 ---
--- 访问外部类的成员 ---
访问外部类实例变量: 这是外部类的实例变量
访问外部类静态变量: 这是外部类的静态变量
外部类的实例方法被调用了
外部类的静态方法被调用了
访问内部类自己的变量: 这是内部类的变量

静态内部类

使用 static 关键字修饰的内部类，它不持有外部类的隐式引用，它更像是一个外部类的“静态成员”。

规则：

• 不能直接访问外部类的实例变量和实例方法，因为它不知道具体是哪个外部类的实例。
• 可以直接访问外部类的静态变量和静态方法，因为这些静态成员属于类本身，不依赖于任何实例。
• 如果想访问外部类的实例成员,必须先创建一个外部类的实例，然后通过这个实例去访问。

示例代码：

public class OuterClassForStatic {
    // 外部类的实例变量
    private String outerInstanceVariable = "这是外部类的实例变量";
    // 外部类的静态变量
    private static String outerStaticVariable = "这是外部类的静态变量";
    // 定义一个静态内部类
    static class StaticInnerClass {
        public void accessOuterMembers() {
            System.out.println("--- 静态内部类尝试访问外部类成员 ---");
            // 1. 直接访问外部类的静态变量 - OK
            System.out.println("访问外部类静态变量: " + outerStaticVariable);
            // 2. 直接访问外部类的实例变量 - 编译错误！
            // System.out.println("访问外部类实例变量: " + outerInstanceVariable);
            // 错误信息: Non-static variable outerInstanceVariable cannot be referenced from a static context
            // 3. 如果想访问外部类的实例成员，必须先创建外部类实例
            System.out.println("--- 创建外部类实例后访问 ---");
            OuterClassForStatic outer = new OuterClassForStatic();
            System.out.println("通过外部类实例访问: " + outer.outerInstanceVariable);
        }
    }
}

如何运行：

public class Main {
    public static void main(String[] args) {
        // 创建静态内部类实例，不需要外部类实例
        // 语法: new 外部类名.静态内部类()
        OuterClassForStatic.StaticInnerClass staticInner = new OuterClassForStatic.StaticInnerClass();
        // 调用方法
        staticInner.accessOuterMembers();
    }
}

输出结果：

--- 静态内部类尝试访问外部类成员 ---
访问外部类静态变量: 这是外部类的静态变量
--- 创建外部类实例后访问 ---
通过外部类实例访问: 这是外部类的实例变量

总结与对比

何时使用哪种内部类？

• 使用非静态内部类：

  • 当内部类需要频繁地、紧密地访问外部类的实例数据时。
  • 当内部类的逻辑与外部类的特定实例强相关时。
  • 常见的例子：事件监听器（如 Button 的 OnClickListener）、迭代器、集合中的节点等。

• 使用静态内部类：

  • 当内部类只需要访问外部类的静态数据时。
  • 当你想将一个类逻辑上组织在另一个类内部,但又不想让它隐式地持有外部类的引用，以避免不必要的内存开销。
  • 常见的例子：Map 接口中的 Entry 实现，或者为了代码组织，将一些辅助类放在主类内部。

理解这两者的区别对于编写清晰、高效的 Java 代码至关重要。