【大话设计模式】简单工厂模式

一：题目
使用Java面向对象语言实现一个计算器控制程序，计算两个数
二：直接写

/**
 * @Author RYF
 * @Description 计算操作一体化
 * @Date 2019-05-17
 **/
public class CalcOperation {
    public static void main(String[] args) {
        int calcNumberA = 2;
        int calcNumberB = 1;
        String operate = "/";
        double result = 0;
        switch (operate){
            case "+":
                result = calcNumberA + calcNumberB;
                break;
            case "-":
                result = calcNumberA - calcNumberB;
                break;
            case "*":
                result = calcNumberA * calcNumberB;
                break;
            case "/":
                if(calcNumberB != 0){
                    result = calcNumberA / calcNumberB;
                }else{
                    throw new IllegalArgumentException("除数不能为0");
                }
                break;
            default:
                throw new IllegalArgumentException("没有 " +operate+" 操作符");
        }
        System.out.println(result);
    }
}

这种写法虽然能够实现计算，但是没有体现面向对象
三：封装（代码的复用而不是复制）
如果有多个地方要进行计算，如果每次都直接复制就会产生代码冗余，这个时候就需要封装来进行代码复用了
1：将计算类过程封装起来

/**
 * @Author RYF
 * @Description 封装的思想，封装计算
 * @Date 2019-05-17
 **/
public class Operation {
    public static double getResult(int calcNumberA,int calcNumberB,String operate){
        if(operate == null){
            throw new IllegalArgumentException("操作符不能为null");
        }
        double result = 0;
        switch (operate){
            case "+":
                result = calcNumberA + calcNumberB;
                break;
            case "-":
                result = calcNumberA - calcNumberB;
                break;
            case "/":
                if(calcNumberB != 0){
                    result = calcNumberA / calcNumberB;
                }else{
                    throw new IllegalArgumentException("除数不能为0");
                }
                break;
            default:
                throw new IllegalArgumentException("没有 " +operate+" 操作符");
        }
        return result;
     }
}

2：调用计算另写，这样来，就可以在多个地方实现计算了

public static void main(String[] args) {
    double result = Operation.getResult(1,2,"+");
    System.out.println(result);
    double result1 = Operation.getResult(1,2,"-");
    System.out.println(result1);
}

三：继承和多态
如果想要加上一个乘法运算的话，需要改动switch中加上一个case。但是这样一来，就必须要知道这所有的计算逻辑，因为他们都在同一个方法中。在改动的时候可能也会对其他运算造成影响。这个时候就需要继承和多态了。
1：接口

public interface IOperation {
     double getResult(double calcNumberA ,double calcNumberB);
}

2：加法

public class OperationAdd implements IOperation{
    @Override
    public double getResult(double calcNumberA,double calcNumberB) {
        return calcNumberA + calcNumberB;
    }
}

3：减法

public class OperationSub implements IOperation {
    @Override
    public double getResult(double calcNumberA,double calcNumberB) {
        return calcNumberA - calcNumberB;
    }
}

4：除法

public class OperationDiv implements IOperation {
    @Override
    public double getResult(double calcNumberA,double calcNumberB) {
        if(calcNumberB == 0){
            throw new IllegalArgumentException("除数不能为0");
        }
        return calcNumberA / calcNumberB;
    }
}

5：简单工厂模式

/**
 * @Author RYF
 * @Description 简单工程模式
 * @Date 2019-05-17
 **/
public class OperationSimpleFactory {
    public static IOperation createOperation(String operate){
        if(operate == null){
            throw new IllegalArgumentException("操作符不能为null");
        }
        IOperation operation = null;
        switch (operate){
            case "+":
                operation = new OperationAdd();
                break;
            case "-":
                operation = new OperationSub();
                break;
            case "/":
                operation = new OperationDiv();
                break;
            default:
                throw new IllegalArgumentException("没有 "+operate+" 操作符");
        }
        return operation;
    }
}

6：新增乘法运算
按照上述5步通过继承和多态实现计算后，现在我们需要新增一个乘法运算

public class OperationMul implements IOperation {
    @Override
    public double getResult(double calcNumberA,double calcNumberB) {
        return calcNumberA * calcNumberB;
    }
}

然后修改下简单工厂，case中增加乘法

/**
 * @Author RYF
 * @Description 简单工程模式
 * @Date 2019-05-17
 **/
public class OperationSimpleFactory {
    public static IOperation createOperation(String operate){
        if(operate == null){
            throw new IllegalArgumentException("操作符不能为null");
        }
        IOperation operation = null;
        switch (operate){
            case "+":
                operation = new OperationAdd();
                break;
            case "-":
                operation = new OperationSub();
                break;
            case "*":
                operation = new OperationMul();
                break;
            case "/":
                operation = new OperationDiv();
                break;
            default:
                throw new IllegalArgumentException("没有 "+operate+" 操作符");
        }
        return operation;
    }
}

7：实现

public static void main(String[] args) {
    IOperation operation = OperationSimpleFactory.createOperation("/");
    double result = operation.getResult(1,2);
    System.out.println(result);
    IOperation operation1 = OperationSimpleFactory.createOperation("*");
    double result1 = operation1.getResult(1,2);
    System.out.println(result1);
 }

从整篇来看，似乎通过面向对象的思想来解决这个计算运算问题使得代码量变得更多了，但实际上，封装有利于我们提高代码的复用性，使得程序更加的灵活，容易修改。