这其实是面向对象编程中一个非常核心和常见的模式,我们可以把它分解成几个层次：

1. 类 A 的一个方法，调用类 B 的一个方法。
2. 类 B 的方法，在执行过程中，又调用了它自己的另一个方法（或者一个静态工具方法）。
3. 类 B 的方法，可能还调用了类 A 的另一个方法（形成一种交互）。

下面我们通过一个完整的、可运行的例子来清晰地展示这个过程。

场景设定

假设我们有一个简单的订单处理系统：

• OrderProcessor (订单处理器类): 负责接收订单,并调用支付服务来完成支付。
• PaymentService (支付服务类): 负责实际的支付逻辑，它会先验证金额,然后再执行支付操作。

这个流程就完美地体现了“函数调用函数调用函数”： OrderProcessor.processOrder() -> PaymentService.pay() -> PaymentService.validateAmount() (以及可能还有其他工具方法)。

第1步：创建两个类

我们创建两个类：OrderProcessor 和 PaymentService。

类 A: OrderProcessor.java

这个类代表订单处理系统，它有一个方法来处理订单，这个方法会创建一个支付服务对象,并调用它的支付方法。

// OrderProcessor.java
public class OrderProcessor {
    // 这是一个实例方法，用于处理订单
    public void processOrder(String orderId, double amount) {
        System.out.println("【OrderProcessor】开始处理订单，订单ID: " + orderId);
        // 1. 创建一个 PaymentService 的实例
        // 这是为了能够调用 PaymentService 的非静态方法
        PaymentService paymentService = new PaymentService();
        // 2. 调用 PaymentService 的 pay() 方法
        // 这就是第一个“函数调用”
        paymentService.pay(orderId, amount);
        System.out.println("【OrderProcessor】订单 " + orderId + " 处理流程结束。");
    }
}

类 B: PaymentService.java

这个类代表支付服务，它有一个 pay() 方法，这个方法内部会调用它自己的另一个辅助方法 validateAmount() 来进行验证。

// PaymentService.java
public class PaymentService {
    /**
     * 这是支付方法，会被 OrderProcessor 调用。
     * 它本身又会调用内部的验证方法。
     */
    public void pay(String orderId, double amount) {
        System.out.println("  【PaymentService】收到支付请求，订单ID: " + orderId + ", 金额: " + amount);
        // 3. 在 pay() 方法内部，调用它自己的另一个方法 validateAmount()
        // 这就是第二个“函数调用”（函数调用函数）
        boolean isValid = this.validateAmount(amount);
        if (isValid) {
            System.out.println("  【PaymentService】金额验证通过，正在执行支付...");
            // 这里可以添加真正的支付逻辑，比如调用第三方API
            System.out.println("  【PaymentService】支付成功！订单 " + orderId + " 已完成。");
        } else {
            System.out.println("  【PaymentService】金额验证失败，支付取消！");
        }
    }
    /**
     * 这是一个私有的辅助方法，用于验证金额。
     * 它只被 PaymentService 内部的方法调用。
     */
    private boolean validateAmount(double amount) {
        System.out.println("    【PaymentService.validateAmount】正在验证金额: " + amount);
        // 简单的业务逻辑：金额必须大于0
        return amount > 0;
    }
}

第2步：创建一个主类来运行程序

为了让程序能够运行，我们需要一个包含 main 方法的类，这个类会创建 OrderProcessor 的实例,并调用它的方法来启动整个流程。

Main.java

// Main.java
public class Main {
    public static void main(String[] args) {
        System.out.println("--- 开始模拟订单处理流程 ---");
        // 1. 创建 OrderProcessor 的实例
        OrderProcessor processor = new OrderProcessor();
        // 2. 调用 OrderProcessor 的 processOrder 方法
        // 这是我们程序的入口点
        System.out.println("\n--- 场景1：处理一个有效订单 ---");
        processor.processOrder("ORD-12345", 100.50);
        System.out.println("\n----------------------------------\n");
        System.out.println("--- 场景2：处理一个无效订单（金额为负） ---");
        processor.processOrder("ORD-67890", -20.0);
        System.out.println("\n--- 模拟订单处理流程结束 ---");
    }
}

第3步：运行和结果分析

你可以编译并运行 Main.java。

编译命令:

javac Main.java OrderProcessor.java PaymentService.java

运行命令:

java Main

输出结果:

--- 开始模拟订单处理流程 ---
--- 场景1：处理一个有效订单 ---
【OrderProcessor】开始处理订单，订单ID: ORD-12345
  【PaymentService】收到支付请求，订单ID: ORD-12345, 金额: 100.5
    【PaymentService.validateAmount】正在验证金额: 100.5
  【PaymentService】金额验证通过，正在执行支付...
  【PaymentService】支付成功！订单 ORD-12345 已完成。
【OrderProcessor】订单 ORD-12345 处理流程结束。
----------------------------------
--- 场景2：处理一个无效订单（金额为负） ---
【OrderProcessor】开始处理订单，订单ID: ORD-67890
  【PaymentService】收到支付请求，订单ID: ORD-67890, 金额: -20.0
    【PaymentService.validateAmount】正在验证金额: -20.0
  【PaymentService】金额验证失败，支付取消！
【OrderProcessor】订单 ORD-67890 处理流程结束。
--- 模拟订单处理流程结束 ---

核心概念解析

1. 对象实例化与引用

   • 在 OrderProcessor 中，PaymentService paymentService = new PaymentService(); 这行代码创建了 PaymentService 类的一个实例（或称为对象）。paymentService 是指向这个对象的引用。
   • 只有通过这个引用，OrderProcessor 才能访问 PaymentService 的方法。

2. 方法调用链

   • Main.main() -> OrderProcessor.processOrder() -> PaymentService.pay() -> PaymentService.validateAmount()
   • 这就是典型的“函数调用函数调用函数”，调用沿着这条链逐级向下进行，每一层都可以完成自己的任务，然后将结果（或继续执行）返回给上一层。

3. this 关键字

   • 在 PaymentService 的 pay() 方法中，this.validateAmount(amount) 的 this 指的是当前这个 PaymentService 对象本身，在实例方法中，this 可以省略，所以通常直接写成 validateAmount(amount),它明确表示调用的是当前类的方法。

4. 封装性

   • PaymentService 的 validateAmount() 方法被声明为 private，这意味着它只能在 PaymentService 类的内部被访问（就像 pay() 方法那样），外部类（如 OrderProcessor 或 Main）无法直接调用它，这体现了封装的原则，隐藏了实现的细节，只暴露必要的公共接口（如 pay()）。

这个例子清晰地展示了：

• 两个类如何协作：OrderProcessor 依赖 PaymentService 来完成支付功能。
• 方法调用的层次：一个类的方法可以调用另一个类的方法,也可以调用自己内部的辅助方法。
• 面向对象的核心思想：将数据和操作数据的方法封装在类中，通过对象之间的交互来完成复杂的任务，这比把所有代码都写在一个巨大的 main 方法里要清晰、可维护得多。