Java中实现类间协作：如何优雅地调用现有对象方法而无需重复创建实例

public class Car {
    private double fuelLevel;
    private boolean engineOn;
    private String model;

    public Car(String model, double initialFuel) {
        this.model = model;
        this.fuelLevel = initialFuel;
        this.engineOn = false; // 初始引擎关闭
        System.out.println(model + " 汽车已创建，初始油量: " + initialFuel + " 升。");
    }

    public void startEngine() {
        if (!engineOn) {
            engineOn = true;
            System.out.println(model + " 引擎启动。");
        } else {
            System.out.println(model + " 引擎已在运行。");
        }
    }

    public void stopEngine() {
        if (engineOn) {
            engineOn = false;
            System.out.println(model + " 引擎关闭。");
        } else {
            System.out.println(model + " 引擎已关闭。");
        }
    }

    public boolean isEngineOn() {
        return engineOn;
    }

    public void consumeFuel(double amount) {
        if (fuelLevel >= amount) {
            fuelLevel -= amount;
            System.out.printf("%s 消耗 %.2f 升燃油，剩余油量: %.2f 升。\n", model, amount, fuelLevel);
        } else {
            System.out.printf("%s 燃油不足，无法消耗 %.2f 升。当前油量: %.2f 升。\n", model, amount, fuelLevel);
            stopEngine(); // 燃油不足时自动关闭引擎
        }
    }

    public double getFuelLevel() {
        return fuelLevel;
    }

    public String getModel() {
        return model;
    }
}

public class FuelConsumptionMonitor {
    /**
     * 根据汽车状态计算并消耗燃油。
     * @param car 需要操作的 Car 对象
     * @param durationMinutes 持续时间（分钟）
     */
    public void monitorAndConsume(Car car, int durationMinutes) {
        // 参数校验，确保 Car 对象不为空
        if (car == null) {
            System.out.println("错误：Car 对象不能为 null，无法监控燃油消耗。");
            return;
        }

        System.out.printf("\n--- 监控 %s 的燃油消耗 (%d 分钟) ---\n", car.getModel(), durationMinutes);

        double consumptionRatePerMinute = 0; // 每分钟消耗量
        if (car.isEngineOn()) {
            consumptionRatePerMinute = 0.8; // 引擎开启，静止状态下每分钟消耗 0.8 升
            System.out.println(car.getModel() + " 引擎已启动，按静止状态消耗燃油。");
            // 假设这里可以根据其他状态（如行驶）调整消耗率
            // if (car.isMoving()) { consumptionRatePerMinute = 6.0; } // 示例：如果Car有isMoving方法
        } else {
            System.out.println(car.getModel() + " 引擎未启动，不消耗燃油。");
            return; // 引擎未启动则不消耗
        }

        double totalConsumption = consumptionRatePerMinute * durationMinutes;
        car.consumeFuel(totalConsumption); // 调用传入 Car 对象的 consumeFuel 方法
        System.out.printf("--- 监控结束，%s 剩余油量: %.2f 升 ---\n", car.getModel(), car.getFuelLevel());
    }

    /**
     * 仅计算预期燃油消耗量，不实际消耗。
     * @param car 需要查询的 Car 对象
     * @param durationMinutes 持续时间（分钟）
     * @return 预期的燃油消耗量
     */
    public double calculateExpectedConsumption(Car car, int durationMinutes) {
        if (car == null || !car.isEngineOn()) {
            return 0;
        }
        double consumptionRatePerMinute = 0.8;
        // if (car.isMoving()) { consumptionRatePerMinute = 6.0; }
        return consumptionRatePerMinute * durationMinutes;
    }
}

public class Main {
    public static void main(String[] args) {
        // 1. 在主方法中创建 Car 对象实例
        Car myCar = new Car("Tesla Model S", 50.0); // 创建一个名为 "Tesla Model S" 的汽车，初始油量50升

        // 2. 创建 FuelConsumptionMonitor 对象实例
        FuelConsumptionMonitor monitor = new FuelConsumptionMonitor();

        // 3. 调用 Car 对象的方法，改变其状态
        myCar.startEngine(); // 启动汽车引擎

        // 4. 将 myCar 对象作为参数传递给 FuelConsumptionMonitor 的方法
        // 这样，FuelConsumptionMonitor 操作的就是 myCar 这个具体的、已存在的实例
        System.out.println("\n--- 第一次燃油消耗监控 ---");
        monitor.monitorAndConsume(myCar, 10); // 监控10分钟的燃油消耗

        // 模拟汽车行驶一段时间后的状态变化
        System.out.println("\n--- 模拟汽车状态变化后再次监控 ---");
        myCar.stopEngine(); // 先关闭引擎
        myCar.startEngine(); // 再次启动引擎
        monitor.monitorAndConsume(myCar, 5); // 监控5分钟

        // 尝试在引擎关闭时进行监控
        System.out.println("\n--- 尝试在引擎关闭时监控 ---");
        myCar.stopEngine(); // 关闭引擎
        monitor.monitorAndConsume(myCar, 3); // 此时不应消耗燃油

        // 尝试油量不足时的消耗
        System.out.println("\n--- 尝试油量不足时的消耗 ---");
        myCar.startEngine();
        monitor.monitorAndConsume(myCar, 100); // 尝试消耗大量燃油，导致油量不足
    }
}

Tesla Model S 汽车已创建，初始油量: 50.0 升。
Tesla Model S 引擎启动。

--- 第一次燃油消耗监控 ---
Tesla Model S 引擎已启动，按静止状态消耗燃油。
Tesla Model S 消耗 8.00 升燃油，剩余油量: 42.00 升。
--- 监控结束，Tesla Model S 剩余油量: 42.00 升 ---

--- 模拟汽车状态变化后再次监控 ---
Tesla Model S 引擎关闭。
Tesla Model S 引擎启动。
Tesla Model S 引擎已启动，按静止状态消耗燃油。
Tesla Model S 消耗 4.00 升燃油，剩余油量: 38.00 升。
--- 监控结束，Tesla Model S 剩余油量: 38.00 升 ---

--- 尝试在引擎关闭时监控 ---
Tesla Model S 引擎关闭。
Tesla Model S 引擎未启动，不消耗燃油。
--- 监控结束，Tesla Model S 剩余油量: 38.00 升 ---

--- 尝试油量不足时的消耗 ---
Tesla Model S 引擎启动。
Tesla Model S 引擎已启动，按静止状态消耗燃油。
Tesla Model S 燃油不足，无法消耗 80.00 升。当前油量: 38.00 升。
Tesla Model S 引擎关闭。
--- 监控结束，Tesla Model S 剩余油量: 38.00 升 ---