1.业务需求

​ 大家好，我是菠菜。在介绍这期简单工厂设计模式前，我们先来看看这样的需求：制作一个简单的计算器，能够实现控制台输入俩个数以及运算符完成运算。

2.初步实现

实现第一版思路：

​ 创建计算器类，控制台输入俩个数以及运算符，通过if条件输出运算结果。

CalClient 类：

public class CalClient {
    public static void main(String[] args) {

        Scanner sc=new Scanner(System.in);
        System.out.println("请输入第一个数：");
        double numbera=sc.nextDouble();
        System.out.println("请输入运算符：");
        String operator=sc.next();
        System.out.println("请输入第二个数：");
        double numberb=sc.nextDouble();
        
        if("+".equals(operator)){
            System.out.println("运算结果为："+(numbera+numberb));
        }else  if("-".equals(operator)){
            System.out.println("运算结果为："+(numbera-numberb));
        }else  if("*".equals(operator)){
            System.out.println("运算结果为："+(numbera*numberb));
        }else  if("/".equals(operator)){
            if(numberb==0){
                System.out.println("除数不能为零");
                return;
            }
            System.out.println("运算结果为："+(numbera/numberb));
        }
    }
}

​ 思考：这段代码在当时初学编程来说，没有问题，而且结果都能执行成功并输出。但是现在我们再来看是不是有点不太满意的地方，比如：计算控制台逻辑和计算方法逻辑耦合在一起，不满足上一期我们所学的单一职责原则，于是我又优化了一版。

实现第二版思路：

​ 增加Operation运算类，将计算方法封装到里面，把计算控制台逻辑和计算方法拆开，降低耦合。

Operation类：

public class Operation {

    public static Double getOperationResult(double numbera,double numberb,String operator){
        Double result=null;

        switch (operator){
            case "+":
                result=numbera+numberb;
                break;
            case "-":
                result=numbera-numberb;
                break;
            case "*":
                result=numbera*numberb;
                break;
            case "/":
                if(numberb==0){
                    System.out.println("除数不能为零");
                    return result;
                }
                result=numbera/numberb;
                break;
        }

        return result;
    }
}

CalClient类：

public class CalClient {
    public static void main(String[] args) {

        Scanner sc=new Scanner(System.in);
        System.out.println("请输入第一个数：");
        double numbera=sc.nextDouble();
        System.out.println("请输入运算符：");
        String operator=sc.next();
        System.out.println("请输入第二个数：");
        double numberb=sc.nextDouble();

    //2.将业务逻辑和界面逻辑分开 解耦
    System.out.println("运算结果为："+(Operation.getOperationResult(numbera,numberb,operator)));
    }
}

​ **思考：**上述代码，虽然将控制台和计算方法解耦，而且这个计算方法类可以做到一定程度上的复用，但是又有了一些新的问题：后续添加或修改计算方法要修改整个Operation类并编译，不安全而且会影响到正常运行的代码，而且该设计没有面向对象编程。我思考了一下，于是就有了下一个升级版本。

3.方案改进

实现第三版本思路：

​ 增加类OperationFactory，用于实例化具体的计算实例。增加抽象类AOpeartion，提取统一计算方法。增加计算实现类OperationAdd、OperationSub、OperationMul、OperationDiv。

OperationFactory类：

public class OperationFactory {

    public static AOpeartion createOperation(String operator){
        AOpeartion opeartion=null;
        switch (operator){
            case "+":
                opeartion=new OperationAdd();
                break;
            case "-":
                opeartion=new OperationSub();
                break;
            case "*":
                opeartion=new OperationMul();
                break;
            case "/":
                opeartion=new OperationDiv();
                break;
        }

        return opeartion;
    }
}

AOpeartion类：

public abstract class AOpeartion {
    public abstract Double getOperationResult(double numbera, double numberb);
}

OperationAdd类：

public class OperationAdd extends AOpeartion {
    @Override
    public Double getOperationResult(double numbera, double numberb) {
        return numbera+numberb;
    }
}

OperationSub类：

public class OperationSub extends AOpeartion {
    @Override
    public Double getOperationResult(double numbera, double numberb) {
        return numbera-numberb;
    }
}

OperationMul类：

public class OperationMul extends AOpeartion {
    @Override
    public Double getOperationResult(double numbera, double numberb) {
        return numbera*numberb;
    }
}

OperationDiv类：

public class OperationDiv extends AOpeartion {
    @Override
    public Double getOperationResult(double numbera, double numberb) {
        if(numberb==0){
            System.out.println("除数不能为零");
            return null;
        }
        return numbera/numberb;
    }
}

CalClient类：

public class CalClient {
    public static void main(String[] args) {

        Scanner sc=new Scanner(System.in);
        System.out.println("请输入第一个数：");
        double numbera=sc.nextDouble();
        System.out.println("请输入运算符：");
        String operator=sc.next();
        System.out.println("请输入第二个数：");
        double numberb=sc.nextDouble();

     //3.利用简单工厂实现 易维护 易复用 易拓展
        AOpeartion opeartion=OperationFactory.createOperation(operator);
        if(null!=opeartion){
            System.out.println("运算结果为："+(opeartion.getOperationResult(numbera,numberb)));
        }else{
            System.out.println("运算工厂获取运算类失败");

        }

    }
}

​ 思考：OperationFactory工厂类通过输入的运算符去实例化相应合适的对象，通过多态返回父类的方式实现了计算器的结果。后续如果修改具体的计算方法只要修改具体的计算类即可，不会影响其它计算类。如果增加计算方法，增加实现相应的计算类的具体子类以及增加计算工厂类的switch分支即可。

4.定义和组成结构

​ 工厂模式的定义：定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。按实际业务场景划分，工厂模式有 3 种不同的实现方式，分别是简单工厂模式、工厂方法模式和抽象工厂模式。我们把被创建的对象称为“产品”，把创建产品的对象称为“工厂”。如果要创建的产品不多，只要一个工厂类就可以完成，这种模式叫“简单工厂模式”。在简单工厂模式中创建实例的方法通常为静态（static）方法，因此简单工厂模式（Simple Factory Pattern）又叫作静态工厂方法模式（Static Factory Method Pattern）。

简单工厂模式的主要角色如下：

​ 简单工厂（SimpleFactory）：是简单工厂模式的核心，负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。
​ 抽象产品（AbstractProduct）：是简单工厂创建的所有对象的父类，负责描述所有实例共有的公共接口。
​ 具体产品（ConcreteProduct）：是简单工厂模式的具体创建目标。

5.优缺点以及应用场景

优点：

• 简单工厂模式实现了对象创建和使用的分离，职责分明
• 客户端无需知道所创建具体对象的类名，只需知道参数即可

缺点:

• 工厂类集中了所有产品的创建逻辑，职责过重
• 系统扩展困难，添加新产品要修改原有逻辑,违反了开闭原则，产品种类一多，工厂类逻辑过于复杂，不利有扩展和维护

应用场景： 对于产品种类相对较少的情况，考虑使用简单工厂模式。使用简单工厂模式的客户端只需要传入工厂类的参数，不需要关心如何创建对象的逻辑，可以很方便地创建所需产品。

友情提示：请尊重作者劳动成果，如需转载本博客文章请注明出处！谢谢合作！
【作者：我爱吃菠菜 个人博客地址】