（Simple Factory Pattern）简单工厂模式

简单工厂模式概述

---

1. 定义：定义一个工厂类，他可以根据参数的不同返回不同类的实例，被创建的 实例通常都具有共同的父类
2. 简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）加粗样式模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。
3. 需要什么，只需要传入一个正确的参数，就可以获取所需要的对象，而无需知道其实现过程

简单工厂模式实现举例

---

例：制作一个四则运算器，实现加减乘除

这个例子中，不使用工厂也可以实现，但现在学习的是简单工厂模式，所以用简单工厂模式实现，也可以从中体现简单工厂模式的一些优点。

上图是该题目的UML类图，设计一个抽象类运算类Operation，里面的A和B是要计算的两个数，GetResult()是抽象方法，四则运算加减乘除分别继承Operation类，并分别实现父类的抽象方法GetResult()方法，当然核心的就是工厂了OperationFactory类了，这个工厂的功能是通过你输入的运算符号，然后实例化出相应的对象，通过多态，返回父类的方式实现运算器的结果

相应代码如下：

//运算类Operation
public abstract class Operation {
    
    private double numberA;
    private double numberB;
    
    public double getNumberA() {
        return numberA;
    }
    public void setNumberA(double numberA) {
        this.numberA = numberA;
    }
    
    public double getNumberB() {
        return numberB;
    }
    public void setNumberB(double numberB) {
        this.numberB = numberB;
    }
    
    public abstract double GetResult();
}

//加减乘除运算，如果运算器需要扩展，就可以在工厂中加入相应运算符，然后在此处增添一个新类实现
public class OperationAdd extends Operation{

    public double GetResult() {
        double result = 0;
        result = this.getNumberA() + this.getNumberB();
        return result;
    }
}
public class OperationDiv extends Operation {

    public double GetResult() {
        double result = 0;
        if(this.getNumberB() == 0) System.out.println("error");
        result = this.getNumberA() / this.getNumberB();
        return result;
    }  
}
public class OperationMul extends Operation {

    public double GetResult() {
        double result = 0;
        result = this.getNumberA() * this.getNumberB();
        return result;
    }
}
public class OperationSub extends Operation {

    public double GetResult() {
        double result = 0;
        result = this.getNumberA() - this.getNumberB();
        return result;
    }
}

//这个就是工厂了，在这里实例化相应的对象
public class OperationFactory {

    public static Operation createOperation(String operate) {
        Operation oper = null;
        switch(operate) {
            case "+":
                oper = new OperationAdd();
                break;
            case "-":
                oper = new OperationSub();
                break;
            case "*":
                oper = new OperationMul();
                break;
            case "/":
                oper = new OperationDiv();
                break;
        }
        return oper;
    }
}

public class Caculator {
//这里就是相应的调用了
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Scanner in =new Scanner(System.in);
        
        System.out.println("A:");//输入数字A
        double A = in.nextDouble();
        
        System.out.println("strOper:");//输入运算符
        String strOper = in.next();
        
        System.out.println("B:");//输入数字B
        double B = in.nextDouble();
        
        Operation oper;
        oper = OperationFactory.createOperation(strOper);//调用工厂实例化
        oper.setNumberA(A);//传入数字A
        oper.setNumberB(B);//传入数字B
        double result = oper.GetResult();//获取运算结果
        System.out.println(result);
        
    }
}

总结：

通过制作四则运算器的过程可以清楚了解简单工厂模式的结构：

• Factory(工厂): 核心部分，也就是我们的OperationFactory类，负责实现创建所有产品的内部逻辑，工厂类可以被外界直接调用，创建所需对象
• Product(抽象类产品)： 工厂类所创建的所有对象的父类，就是我们创建的
  运算类Operation，封装了产品对象的公共方法GetResult()，所有的具体产品为其子类对象
• ConcreteProduct(具体产品)： 简单工厂模式的创建目标，所有被创建的对象都是某个具体类的实例，就是具体的加减乘除运算类的实现。它要实现抽象产品中声明的抽象方法(有关抽象类)

了解简单工厂模式的优缺点：

• 简单工厂模式的优点

1. 工厂类包含必要的逻辑判断，可以决定在什么时候创建哪一个产品的实 例。客户端可以免除直接创建产品对象的职责
2. 客户端无需知道所创建具体产品的类名，只需知道参数即可
3. 也可以引入配置文件，在不修改客户端代码的情况下更换和添加新的具体产品类。（这也是我在开始的披萨店里遇到没有的披萨的解决情况）

• 简单工厂模式的缺点

1. 工厂类集中了所有产品的创建逻辑，职责过重，一旦异常，整个系统将受影响
2. 使用简单工厂模式会增加系统中类的个数(引入新的工厂类)，增加系统的复杂度和理解难度
3. 系统扩展困难，一旦增加新产品不得不修改工厂逻辑，在产品类型较多时，可能造成逻辑过于复杂
4. 简单工厂模式使用了static工厂方法，造成工厂角色无法形成基于继承的等级结构。

• 简单工厂模式的使用环境

1. 工厂类负责创建对的对象比较少，因为不会造成工厂方法中的业务逻辑过于复杂
2. 客户端只知道传入工厂类的参数，对如何创建对象不关心