Java：如何在FuelConsumption类中调用已创建的Car对象方法？

你需要的是依赖注入的思路——把Main中已经创建好的Car对象，传递给FuelConsumption类的方法或者实例，这样就能直接调用该Car对象的方法，不需要新建实例，也不用static方法，同时保持类职责的清晰。

下面是两种常用的实现方式：

方式1：将Car对象作为方法参数传递 #

这种方式适合单次调用油耗计算的场景，每次计算时把目标Car对象传给FuelConsumption的方法：

代码示例 #

// 简化的Car类（保留核心状态和方法）
public class Car {
    private boolean engineRunning;
    private double fuelLevel;

    // 已有方法：启动引擎、熄火、加油等
    public void startEngine() {
        this.engineRunning = true;
    }
    public void stopEngine() {
        this.engineRunning = false;
    }
    public boolean getEngineRunning() {
        return engineRunning;
    }
    public double getFuelLevel() {
        return fuelLevel;
    }
    public void setFuelLevel(double fuelLevel) {
        this.fuelLevel = fuelLevel;
    }
    public void addFuel(double amount) {
        this.fuelLevel += amount;
    }
}

// FuelConsumption类
public class FuelConsumption {
    // 引擎怠速油耗计算：每分钟0.8升
    public void calculateIdleConsumption(Car car, long durationMs) {
        if (!car.getEngineRunning()) {
            System.out.println("引擎未启动，无怠速油耗");
            return;
        }
        double minutes = durationMs / 60000.0;
        double consumedFuel = minutes * 0.8;
        // 调用Car对象的方法更新油量
        car.setFuelLevel(car.getFuelLevel() - consumedFuel);
        System.out.printf("怠速%.2f分钟，消耗燃油%.2f升%n", minutes, consumedFuel);
    }

    // 行驶油耗计算：每分钟6升（测试用6000毫秒即0.1分钟）
    public void calculateDrivingConsumption(Car car, long durationMs) {
        if (!car.getEngineRunning()) {
            System.out.println("引擎未启动，无法行驶");
            return;
        }
        double minutes = durationMs / 60000.0;
        double consumedFuel = minutes * 6;
        car.setFuelLevel(car.getFuelLevel() - consumedFuel);
        System.out.printf("行驶%.2f分钟，消耗燃油%.2f升%n", minutes, consumedFuel);
    }
}

// Main类的调用逻辑
public class Main {
    public static void main(String[] args) {
        // 已有的Car对象
        Car myCar = new Car();
        myCar.addFuel(50); // 给车加50升油
        myCar.startEngine();

        // 实例化FuelConsumption，传入已有的Car对象计算油耗
        FuelConsumption fuelCalc = new FuelConsumption();
        fuelCalc.calculateIdleConsumption(myCar, 30000); // 怠速30秒
        fuelCalc.calculateDrivingConsumption(myCar, 6000); // 行驶6秒
    }
}

方式2：通过构造函数注入Car对象 #

如果FuelConsumption需要持续和同一个Car对象交互（比如多次计算油耗），可以在实例化FuelConsumption时就传入Car对象，保存在类的成员变量中：

代码示例 #

public class FuelConsumption {
    private final Car targetCar; // 保存传入的Car对象

    // 构造函数注入Car对象
    public FuelConsumption(Car car) {
        this.targetCar = car;
    }

    // 怠速油耗计算，无需再传Car参数
    public void calculateIdleConsumption(long durationMs) {
        if (!targetCar.getEngineRunning()) {
            System.out.println("引擎未启动，无怠速油耗");
            return;
        }
        double minutes = durationMs / 60000.0;
        double consumedFuel = minutes * 0.8;
        targetCar.setFuelLevel(targetCar.getFuelLevel() - consumedFuel);
        System.out.printf("怠速%.2f分钟，消耗燃油%.2f升%n", minutes, consumedFuel);
    }

    // 行驶油耗计算
    public void calculateDrivingConsumption(long durationMs) {
        if (!targetCar.getEngineRunning()) {
            System.out.println("引擎未启动，无法行驶");
            return;
        }
        double minutes = durationMs / 60000.0;
        double consumedFuel = minutes * 6;
        targetCar.setFuelLevel(targetCar.getFuelLevel() - consumedFuel);
        System.out.printf("行驶%.2f分钟，消耗燃油%.2f升%n", minutes, consumedFuel);
    }
}

// Main类调用
public class Main {
    public static void main(String[] args) {
        Car myCar = new Car();
        myCar.addFuel(50);
        myCar.startEngine();

        // 实例化FuelConsumption时传入已有的Car对象
        FuelConsumption fuelCalc = new FuelConsumption(myCar);
        fuelCalc.calculateIdleConsumption(30000);
        fuelCalc.calculateDrivingConsumption(6000);
    }
}

为什么这是合理的方案？ #

• 符合单一职责原则：Car类负责车辆的状态和操作（启动、换挡等），FuelConsumption类专注于油耗计算逻辑，职责清晰，后续维护更方便。
• 避免了static方法的弊端：static方法无法依赖实例状态，会让代码耦合度变高，而依赖注入的方式保持了类的实例化特性，更符合面向对象设计。
• 直接复用已有的Car实例：不需要在FuelConsumption中新建Car对象，保证了状态的一致性（比如Main中给Car加的油，FuelConsumption计算后直接更新同一个对象的油量）。

内容的提问来源于stack exchange，提问作者Rares Selaru