设计模式之工厂模式(简单工厂，工厂方法，抽象工厂)

/**
     * 这里简化了验证之类的逻辑
     * @param a1 第一个数字
     * @param a2 第二个数字
     * @param operator 运算符
     * @return
     */
    public static double calculate(double a1 , double a2 , String operator) {
        double result=0;
        switch (operator) {
        case "+":
            result=a1+a2;
            break;
        case "-":
            result=a1-a2;
            break;
        case "*":
            result=a1*a2;
            break;
        case "/":
            result=a1/a2;
            break;
            
        //TODO 也许还有别的这些运算符
        default:
            break;
        }
        return result;
    }
    //本身这样是没问题的而且也是非常简单的方式去实现计算的逻辑
    //如果逻辑简单这样写应该也是没问题的。问题是如果该程序非常复杂，这样的代码是很不好维护的。

//计算方法
//将计算方式抽象成一个类
public abstract class CalculationRule {
    public abstract double getResult(double param1,double param2);
}
//简单的加法
public class AddRule extends CalculationRule {
    @Override
    public double getResult(double param1, double param2) {
        return param1+param2;
    }
}
//简单的减法
public class SubRule extends CalculationRule {
    @Override
    public double getResult(double param1, double param2) {
        return param1-param2;
    }
}

//简单工厂模式(Simple Factory)
public class CalculationRuleFactory {
    public static final String OPR_ADD="+"; //加法
    public static final String OPR_SUB="-"; //减法

    public static CalculationRule getCalculate(String operator) {
        CalculationRule cal=null;
        if (OPR_ADD.contentEquals(operator)) {
            cal=new AddRule();
        }else if(OPR_SUB.contentEquals(operator)) {
            cal=new SubRule();
        }
        return cal;
    }
}

//实际调用方式
public class MainEntry {
    public static void main(String[] args) {
        CalculationRule addRule=CalculationRuleFactory.getCalculate(CalculationRuleFactory.OPR_ADD);//获得加法算法；
        System.out.println(addRule.getResult(0.1,0.2));
    }
}

/**
  * 工厂方法接口
 */
public interface CalculationRuleFactoryInterface {
    CalculationRule getRule();
}
/**
 * 加法工厂
 */
public class AddRuleFactory implements CalculationRuleFactoryInterface {
    @Override
    public CalculationRule getRule() {
        return new AddRule();
    }
}
/**
 * 减法工厂类
 */
public class SubRuleFactory implements CalculationRuleFactoryInterface {
    @Override
    public CalculationRule getRule() {
        return new SubRule();
    }

//调用
public static void main(String[] args) {
        //创建工厂
        CalculationRuleFactoryInterface factory=new SubRuleFactory();
        //请求算法并执行
        System.out.println(factory.getRule().getResult(0.2, 0.1));
    }

//另外一种方式
public class MainEntry {
    //Spring配置注入
    private CalculationRuleFactoryInterface calRulefactory;
    
    public void fire() {
        calRulefactory.getRule().getResult(0.2, 0.1);
    }
    //这样通过配置的方式想用什么算法就用什么算法
}

//我们添加一个抽象类
/**
 * 过程展示
 */
public abstract class ProcessView {
    public abstract void showView(double param1,double param2);
}
//加和减的过程展示都继承这个类
/**
 * 加法过程展示
 */
public class AddProcessView extends ProcessView {
    @Override
    public void showView(double param1, double param2) {
        System.out.println(""+param1+"+"+param2+"="+(param1+param2));
    }
}
/**
 * 减法过程展示
 */
public class SubProcessView extends ProcessView {
    @Override
    public void showView(double param1, double param2) {
        System.out.println(""+param1+"-"+param2+"="+(param1-param2));
    }
}


//我们将ProcessView统一交由CalculationRuleFactoryInterface管理
/**
  * 工厂方法接口
 */
public interface CalculationRuleFactoryInterface {
    CalculationRule getRule();
    ProcessView showProcess();//这个是新加的
}

//同时调整对应的工厂
/**
 * 加法工厂
 */
public class AddRuleFactory implements CalculationRuleFactoryInterface {
    @Override
    public CalculationRule getRule() {
        return new AddRule();
    }
    
    //下面是新加的
    @Override
    public ProcessView showProcess() {
        return new AddProcessView();
    }
}
/**
 * 减法工厂类
 */
public class SubRuleFactory implements CalculationRuleFactoryInterface {
    @Override
    public CalculationRule getRule() {
        return new SubRule();
    }
    
    //下面是新加的
    @Override
    public ProcessView showProcess() {
        return new SubProcessView();
    }
}

//最后尝试调用
public static void main(String[] args) {
        // 创建工厂
        CalculationRuleFactoryInterface factory = new SubRuleFactory();
        // 请求算法并执行
        System.out.println(factory.getRule().getResult(0.2, 0.1));
        // 请求显示过程
        factory.showProcess().showView(0.2, 0.1);
    }