策略模式-Spring下如何使用父类调用对应子类

开发过程中会涉及到根据不同条件需求需要通过不同子类调用实现的需求，

例如一个接口需要制造一辆车，但车分自行车，摩托车，越野车

他们都有同样的需求（父类）：有动力输出，有车体制造，有车轮制造……

但他们各自的需求又不一样（子类）：

        就动力输出来说，自行车的动力输出是踏板链条，摩托车的动力输出是发动机；

        车体制造来说，直行车只需要几根碳纤维管，越野车则需要顶棚、车门、A柱B柱……

这样就有了一个接口根据参数不同，统一调用不同接口实现类的需求

首先，创建一个造车的接口，接口参数里边有车的类型，车的数量：

public interface IMakeVehicle {
    /**
     * 声明一个制造车辆的接口
     * @param vehicleType 车辆类型
     * @param number 需要的数量
     * @return 制造结果
     */
    String makeVehicleByType(String vehicleType,Integer number);
}

第二步，构造当前接口的实现类，模拟参数返回，保证链路畅通

@Component
class MakeVehicle implements IMakeVehicle {

    @Override
    public String makeVehicleByType(String vehicleType,Integer number){
        return "SUCCESS";
    }
}

---

以上已经构造出了基本需求：一个可以造车的接口

接下来看如何用父类子类实现这个需求

先构建一个造车的接口（制作车辆的流水线入口）：

public interface Make {
    /**
     * 开始制造车辆的方法
     * @param number 车辆数量
     * @return 制造结果
     */
    String makeVehicleDoing(Integer number);
}

再写一个制造车辆的父类，其中包含了制造车辆的所有方法，以及最后的整合包装流水线实现类

public abstract class AbstractMake implements Make {

    @Override
    public String makeVehicleDoing(Integer number){
        StringBuffer vehicle = new StringBuffer();
        vehicle.append(getDynamicSystem());
        vehicle.append(getAppearance());
        vehicle.append(getWheelNumber(number));
        return vehicle.toString();
    }

    /**
     * 获取动力系统
     * @return 返回当前订单车辆的动力系统
     */
    protected abstract String getDynamicSystem();

    /**
     * 获取车辆外观
     * @return 返回当前订单车辆的外观
     */
    protected abstract String getAppearance();

    /**
     * 获取车轮数量
     * @param carNumber 车辆数量
     * @return 返回当前订单的车轮数量
     */
    protected abstract Integer getWheelNumber(Integer carNumber);
}

接着，就可以在各自的子类中做各自的事了，并通过@Component注解区分各个子类，例如：

自行车，

@Component("Bicycle")
public class BicycleMake extends AbstractMake {

    @Override
    public String getDynamicSystem(){
        return "踏板和链条";
    }

    @Override
    public String getAppearance(){
        return "炭纤维车架";
    }

    @Override
    public Integer getWheelNumber(Integer carNumber){
        return carNumber*2;
    }
}

摩托车，

@Component("Motorcycle")
public class MotorcycleMake  extends AbstractMake {

    @Override
    public String getDynamicSystem(){
        return "Yamaha发动机";
    }

    @Override
    public String getAppearance(){
        return "铝镁合金摩托车车架";
    }

    @Override
    public Integer getWheelNumber(Integer carNumber){
        return carNumber*2;
    }
}

以及各种各样的车……

---

最后，修改主接口实现方法，实现不同判断不同参数调用不同子类实现的效果

@Component
class MakeVehicle implements IMakeVehicle {
    /**
     * 注入所有的Make方法
     */
    @Autowired
    private Map<String, Make> makeMap;

    @Override
    public String makeVehicleByType(String vehicleType,Integer number){
        //通过车辆类型字段判断当前引用的是哪个子类
        Make make = getMake(vehicleType);
        //通过不同子类的不同doing方法返回不同结果
        String result = make.makeVehicleDoing(number);
        System.out.println(result);
        if(result != null){
            return "SUCCESS";
        }else{
            return "ERROR";
        }
    }

    private Make getMake(String vehicleType){
        return makeMap.get(vehicleType);
    }
}

END……