1.简单工厂模式

---

记录大话设计模式的笔记

---

一、场景描述

请使用任意一种面向对象语言实现一个计算器控制台程序，要求输入两个数和运算符符号，得到结果。

二、初始版本

public class SimpleFactoryPattern {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入数字A：");
        float a = scanner.nextFloat();
        System.out.println("请选择运算符（+、-、*、/）：");
        String operator = scanner.next();
        System.out.println("请输入数字B：");
        float b = scanner.nextFloat();
        float result = 0;

        switch (operator) {
            case "+":
                result = a + b;
                break;
            case "-":
                result = a - b;
                break;
            case "*":
                result = a * b;
                break;
            case "/":
                result = a / b;
                break;
        }
        System.out.println("结果是：" + result);
    }
}

三、存在问题

上面的代码可以实现描述的问题，但是我们把所有的实现细节全都暴露在客户端，而且所有的业务逻辑全都需要在客户端实现，这样虽然没有错，但是这样的思维却使得我们的程序只能满足当前的需求，如果需求变了，那么我们每次都需要去修改原有的代码，这样的程序不容易维护、扩展和复用。

我们可以采用面向对象的思维去思考问题，通过封装、继承、多态把程序的耦合度降低，用设计模式使得程序更加的灵活、容易维护，并且易于复用。

针对上面的问题，我们可以先把业务逻辑和客户端分开，针对业务逻辑，可以再使用继承和多态，将里面的运算逻辑优化一下，不是写死一段逻辑代码，而是将它抽象出来，否则当我们需要再增加一种运算符的时候，每次都需要去修改判断逻辑里面的代码，写一段业务代码在switch里面，这样就不太灵活了。

四、优化版本

结构图

代码

/**
 * 定义一个父类，用来规范运算符操作
 */
public abstract class Operation {

    protected float numA = 0;

    protected float numB = 0;

    public abstract float getResult();
}

/**
 * 加法操作，实现父类的方法，并实现具体的逻辑
 */
public class AddOperation extends Operation{

    @Override
    public float getResult() {
        return numA+numB;
    }
}

/**
 * 减法操作，实现父类的方法，并实现具体的逻辑
 */
public class SubOperation extends Operation{

    @Override
    public float getResult() {
        return numA-numB;
    }
}

我们可以把业务逻辑分开成上面的代码，这样写以后呢，当我们需要增加一种新的运算操作时，只需要继承Operation类，并实现想要的逻辑即可，然后呢，我们怎么知道是调用哪个方法呢，这个时候就需要用到简单工厂模式了，具体实现如下：

/**
 * 运算符工厂，根据字符串创建对应的实现类
 */
public class OperationFactory {

    public static Operation createOperate(String operate) {
        Operation operation = null;
        switch (operate) {
            case "+":
                operation = new AddOperation();
                break;
            case "-":
                operation = new SubOperation();
                break;
            case "*":
                operation = new MulOperation();
                break;
            case "/":
                operation = new DivOperation();
                break;
        }
        return operation;
    }
}

Operation operation = OperationFactory.createOperate(operator);
operation.numA = a;
operation.numB = b;
result = operation.getResult();

---

总结

通过这个例子，我们提供了一个工厂来创建多个不同的运算符操作类，而无需暴露其具体的实现细节，客户端只需要知道所需对象的类型，而无需关心对象的具体创建过程和执行方法的逻辑。这样提高了代码的可维护性和灵活性，不会像一开始时那样，所有功能都冗余在一个方法里，当我们修改其中一个地方时，可能还会影响到其他代码。

但是这里也存在一点问题，就是我们把客户端的判断逻辑移到了工厂里面，当我们添加一种新的运算符时，我们需要修改工厂里面的判断逻辑，有没有办法不修改呢？后续的工厂模式就可以解决这个问题。