如何避免针对不同对象使用switch或if/else分支结构

针对你遇到的问题——Car和Motorbike结构差异大导致多态难落地、Mechanic类里满是if/else分支的情况，可以通过参数封装+接口多态+工厂模式的组合方案解决，既消除分支，又保证未来可扩展。

核心思路 #

1. 把不同车辆的维修参数封装成专属DTO，避免零散参数满天飞；
2. 定义统一的Vehicle接口，让所有车辆实现该接口的repair方法，各自处理专属参数；
3. 用工厂模式封装车辆实例的创建逻辑，把分支集中到工厂（而非业务逻辑类），符合开闭原则。

代码实现步骤 #

1. 封装维修参数 #

先为每种车辆创建对应的维修参数类，继承自抽象基类统一管理：

// 抽象维修参数基类
public abstract class RepairParams {}

// 汽车维修参数
public class CarRepairParams extends RepairParams {
    private String steeringWheel;
    private String wheelA;
    private String wheelB;
    private String wheelC;
    private String wheelD;

    public CarRepairParams(String steeringWheel, String wheelA, String wheelB, String wheelC, String wheelD) {
        this.steeringWheel = steeringWheel;
        this.wheelA = wheelA;
        this.wheelB = wheelB;
        this.wheelC = wheelC;
        this.wheelD = wheelD;
    }

    // getter方法
    public String getSteeringWheel() { return steeringWheel; }
    public String getWheelA() { return wheelA; }
    public String getWheelB() { return wheelB; }
    public String getWheelC() { return wheelC; }
    public String getWheelD() { return wheelD; }
}

// 摩托车维修参数
public class MotorbikeRepairParams extends RepairParams {
    private String handlebar;
    private String wheelA;
    private String wheelB;

    public MotorbikeRepairParams(String handlebar, String wheelA, String wheelB) {
        this.handlebar = handlebar;
        this.wheelA = wheelA;
        this.wheelB = wheelB;
    }

    // getter方法
    public String getHandlebar() { return handlebar; }
    public String getWheelA() { return wheelA; }
    public String getWheelB() { return wheelB; }
}

2. 定义统一的Vehicle接口 #

让Car和Motorbike都实现这个接口，各自处理维修逻辑：

public interface Vehicle {
    void repair(RepairParams params);
}

// 汽车实现类
public class Car implements Vehicle {
    private String steeringWheel;
    private String wheelA;
    private String wheelB;
    private String wheelC;
    private String wheelD;

    @Override
    public void repair(RepairParams params) {
        if (!(params instanceof CarRepairParams)) {
            throw new IllegalArgumentException("参数类型错误，需传入CarRepairParams");
        }
        CarRepairParams carParams = (CarRepairParams) params;
        // 执行汽车维修逻辑
        this.steeringWheel = carParams.getSteeringWheel();
        this.wheelA = carParams.getWheelA();
        this.wheelB = carParams.getWheelB();
        this.wheelC = carParams.getWheelC();
        this.wheelD = carParams.getWheelD();
    }
}

// 摩托车实现类
public class Motorbike implements Vehicle {
    private String handlebar;
    private String wheelA;
    private String wheelB;

    @Override
    public void repair(RepairParams params) {
        if (!(params instanceof MotorbikeRepairParams)) {
            throw new IllegalArgumentException("参数类型错误，需传入MotorbikeRepairParams");
        }
        MotorbikeRepairParams bikeParams = (MotorbikeRepairParams) params;
        // 执行摩托车维修逻辑
        this.handlebar = bikeParams.getHandlebar();
        this.wheelA = bikeParams.getWheelA();
        this.wheelB = bikeParams.getWheelB();
    }
}

3. 用工厂模式创建车辆实例 #

把车辆的创建逻辑集中到工厂，消除Mechanic里的分支：

public class VehicleFactory {
    public static Vehicle createVehicle(String type) {
        switch (type) {
            case "car":
                return new Car();
            case "motorbike":
                return new Motorbike();
            default:
                throw new IllegalArgumentException("不支持的车辆类型：" + type);
        }
    }
}

4. 重构Mechanic类 #

现在Mechanic不需要任何分支，直接调用统一方法即可：

public class Mechanic {
    public void repairVehicle(String type, RepairParams params) {
        Vehicle vehicle = VehicleFactory.createVehicle(type);
        vehicle.repair(params);
    }
}

使用示例 #

public class Main {
    public static void main(String[] args) {
        Mechanic mechanic = new Mechanic();

        // 维修汽车
        CarRepairParams carParams = new CarRepairParams("全新方向盘", "左前轮", "右前轮", "左后轮", "右后轮");
        mechanic.repairVehicle("car", carParams);

        // 维修摩托车
        MotorbikeRepairParams bikeParams = new MotorbikeRepairParams("防滑车把", "前轮", "后轮");
        mechanic.repairVehicle("motorbike", bikeParams);
    }
}

扩展优化建议 #

• 用枚举代替字符串类型的车辆标识，避免拼写错误；
• 新增车辆类型时，只需新增XXXVehicle、XXXRepairParams类，并在VehicleFactory中添加对应分支，现有代码无需改动；
• 若想彻底消除工厂里的switch，可结合注解+反射自动扫描所有Vehicle实现类，实现动态注册。

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