请教：该OOP多态示例是否正确？如何用依赖注入彻底解耦代码？

你当前的Driver类设计是符合面向对象原则的——它依赖抽象的Vehicle而非具体子类，但问题出在main方法直接实例化Car、MotorBike，导致main方法与这些具体实现类紧耦合。你改写后的代码只是简化了实例化写法，并没有从根本上解除耦合。

原问题代码 #

public class Driver{
    void drive(Vehicle vehicle){
        vehicle.moveForward();
        vehicle.moveBackward();
    }
}

// 存在紧耦合的代码
public static void main(String[] args){
    Vehicle car = new Car(); // 直接依赖Car类
    Vehicle motorBike = new MotorBike(); // 直接依赖MotorBike类
    Driver driver = new Driver();
    
    driver.drive(car);
    driver.drive(motorBike);
}

你改写的代码 #

// 你改写后的代码
public static void main(String[] args){
    Driver driver = new Driver();
    
    driver.drive(new Car());
    driver.drive(new MotorBike());
}

解决方案：通过工厂模式解耦 #

核心是把具体Vehicle子类的实例化逻辑从main方法中抽离，封装到专门的工厂类中，让上层代码只依赖抽象而非具体实现。

方式一：简单静态工厂

// 车辆工厂类，封装实例化逻辑
public class VehicleFactory {
    public static Vehicle createCar() {
        return new Car();
    }

    public static Vehicle createMotorBike() {
        return new MotorBike();
    }
}

// 修改后的main方法
public static void main(String[] args) {
    Driver driver = new Driver();
    
    driver.drive(VehicleFactory.createCar());
    driver.drive(VehicleFactory.createMotorBike());
}

方式二：抽象工厂（更灵活，符合开闭原则）

如果后续需要新增更多Vehicle子类，这种方式无需修改现有代码，只需新增对应工厂实现：

// 抽象工厂接口
public interface VehicleFactory {
    Vehicle createVehicle();
}

// Car对应的工厂实现
public class CarFactory implements VehicleFactory {
    @Override
    public Vehicle createVehicle() {
        return new Car();
    }
}

// MotorBike对应的工厂实现
public class MotorBikeFactory implements VehicleFactory {
    @Override
    public Vehicle createVehicle() {
        return new MotorBike();
    }
}

// 修改后的main方法
public static void main(String[] args) {
    Driver driver = new Driver();
    
    VehicleFactory carFactory = new CarFactory();
    driver.drive(carFactory.createVehicle());
    
    VehicleFactory bikeFactory = new MotorBikeFactory();
    driver.drive(bikeFactory.createVehicle());
}

说明 #

通过上述改造，main方法不再直接引用Car、MotorBike这些具体类，而是通过工厂获取抽象的Vehicle实例。后续如果要替换Vehicle的实现（比如新增Truck类），只需要修改工厂类或新增对应的工厂实现，无需改动main方法和Driver类，彻底解除了紧耦合。

内容的提问来源于stack exchange，提问作者황희윤