这个问题的核心在于作用域和this引用，当你在内部类中调用一个方法时，Java 编译器需要明确你指的是哪个类的方法，如果直接调用，默认是 this（内部类实例）的方法，要调用外部类的方法,你需要一个明确的指向外部类实例的引用。

Java 提供了一个特殊的语法糖来解决这个问题：外部类名.this。

核心语法

// 在内部类中调用外部类的实例方法
外部类名.this.外部类方法名();
// 在内部类中调用外部类的静态方法
外部类名.外部类静态方法名();

外部类名.this 是关键,它返回一个指向当前内部类实例所绑定的外部类对象的引用。

示例代码

下面我们通过一个完整的例子来演示这个过程，我们将创建一个 OuterClass（外部类），它包含一个 InnerClass（内部类）和一个 showMessage() 方法，然后在内部类中调用这个 showMessage() 方法。

// OuterClass.java
public class OuterClass {
    // 外部类的成员变量
    private String outerMessage = "这是来自外部类的消息";
    // 外部类的实例方法
    public void showMessage() {
        System.out.println("外部类的方法被调用了！消息是: " + outerMessage);
    }
    // 外部类的静态方法
    public static void showStaticMessage() {
        System.out.println("外部类的静态方法被调用了！");
    }
    // 内部类
    class InnerClass {
        public void accessOuterMethod() {
            System.out.println("--- 内部类开始尝试调用外部类的方法 ---");
            // 1. 调用外部类的实例方法
            // 使用 "OuterClass.this" 来明确指定调用外部类的方法
            OuterClass.this.showMessage();
            // 2. 调用外部类的静态方法
            // 静态方法通过类名直接调用，不需要实例引用
            OuterClass.showStaticMessage();
            // 3. 如果没有命名冲突，也可以直接调用（不推荐，容易混淆）
            // 这里的 showMessage() 默认是内部类自己的方法（如果有的话）
            // 如果内部类没有 showMessage()，Java 会自动向上查找，但最好显式声明
            // showMessage(); // 这种写法虽然能工作，但可读性差，不推荐
        }
    }
    // 外部类的一个方法，用于创建内部类实例并调用其方法
    public void testInnerClass() {
        InnerClass inner = new InnerClass();
        inner.accessOuterMethod();
    }
    public static void main(String[] args) {
        // 创建外部类实例
        OuterClass outer = new OuterClass();
        // 调用测试方法，该方法会内部创建内部类实例并触发调用
        outer.testInnerClass();
    }
}

运行结果

--- 内部类开始尝试调用外部类的方法 ---
外部类的方法被调用了！消息是: 这是来自外部类的消息
外部类的静态方法被调用了！

深入解析：为什么需要 OuterClass.this？

为了更好地理解，我们来看看内部类在编译后会发生什么，使用 javac OuterClass.java 编译后，你会发现生成了两个 .class 文件：

1. OuterClass.class
2. OuterClass$InnerClass.class

这说明内部类在底层被编译成了一个独立的类，我们使用反编译工具（如 javap）查看 OuterClass$InnerClass.class 的内容,会发现类似这样的构造器：

// OuterClass$InnerClass 的构造器（伪代码）
public OuterClass$InnerClass(OuterClass this$0) {
    // this$0 是一个隐藏的参数，代表了外部类的实例
    this.this$0 = this$0;
}

这个隐藏的参数 this$0 就是连接内部类和外部类的桥梁，当你创建 new InnerClass() 时，实际上是 new OuterClass$InnerClass(this),外部类的实例被悄悄地传递给了内部类的构造器。

OuterClass.this 实际上就是获取这个隐藏的 this$0 引用,让你能够通过它来访问外部类的成员。

不同类型内部类的调用方式

内部类分为四种,它们的调用方式略有不同。

成员内部类

就是我们上面例子中的类型，最常见，通过 外部类名.this 调用。

静态内部类

静态内部类不持有外部类的引用，它不能直接访问外部类的非静态成员（变量或方法）。

public class OuterClass {
    private String outerMessage = "外部消息";
    public void outerMethod() {
        System.out.println("外部方法");
    }
    // 静态内部类
    static class StaticInnerClass {
        public void access() {
            // 下面这两行代码会编译错误！
            // System.out.println(outerMessage); // Error: 无法从静态上下文中引用非静态 变量 outerMessage
            // outerMethod(); // Error: 无法从静态上下文中引用非静态 方法 outerMethod()
            // 只能访问外部类的静态成员
            // OuterClass.showStaticMessage(); // 假设外部类有这个静态方法
        }
    }
}

局部内部类

定义在方法或作用块内部的类，它可以访问外部类的所有成员，以及定义它的方法中的 final 或有效 final 的局部变量。

调用方式与成员内部类相同,因为它也持有外部类的引用。

public class OuterClass {
    private String outerMessage = "外部消息";
    public void myMethod() {
        String localVar = "局部变量";
        // 局部内部类
        class LocalInnerClass {
            public void show() {
                // 可以访问外部类成员
                System.out.println(outerMessage);
                // 可以访问方法内的 final 变量
                System.out.println(localVar);
            }
        }
        LocalInnerClass lic = new LocalInnerClass();
        lic.show();
    }
}

匿名内部类

没有名字的局部内部类，它通常是作为方法参数或直接实例化一个接口/抽象类,它的访问规则与局部内部类完全相同。

public class OuterClass {
    private String outerMessage = "外部消息";
    public void createAnonymousInnerClass() {
        // 匿名内部类，实现了 Runnable 接口
        Runnable r = new Runnable() {
            @Override
            public void run() {
                // 可以访问外部类的成员
                System.out.println("匿名内部类正在运行: " + outerMessage);
            }
        };
        r.run();
    }
}

最佳实践：

1. 明确性：在内部类中调用外部类方法时，始终使用 外部类名.this.方法名()，这会让代码意图非常清晰,避免混淆。
2. 避免过度使用：内部类会使代码结构变得复杂，如果只是简单的逻辑关联，可以考虑使用组合（持有外部类对象）或单独的类来代替。
3. 注意静态内部类的限制：牢记静态内部类无法直接访问外部类的非静态成员,这是它和普通内部类的最大区别。