简单工厂模式 Single Factory

定义：定义一个工厂类，它可以根据参数不同返回不同类的实例，被创建的实例通常都具有共同的父类。

在简单工厂模式中用于被创建的实例的方法通常为静态方法，因此也被称之为静态工厂方法。

结构：
1、Factory（工厂）：核心部分，负责实现创建所有产品的内部逻辑，工厂类可以被外界直接调用，创建所需对象；

2、Product(抽象类产品)：工厂类所创建的对象的父类，封装了产品对象的公共方法，所有具体的产品为其子类对象；

3、ConcreteProduct（具体产品）：简单工厂模式的创建目标。所有被创建的对象都是某个具体类的实例，它实现首相产品生命的抽象方法。

举个例子 设计一个简单的计算器
UML图

代码实现
1、首先创建一个运算类，Operation类

package com.wilson.calculator.operation;
import lombok.Data;
/**
 * 操作抽象父类
 * 用于给其子类提供操作方法
 */
@Data
public abstract class Operation {
    Double firstNumber;
    Double secondNumber;
    //构造方法用于其子类获取参数的值，进行运算
    public Operation(Double firstNumber, Double secondNumber) {
        this.firstNumber = firstNumber;
        this.secondNumber = secondNumber;
    }
    //用于利用多态获取对应的子类
    public Operation() {
    }
    public abstract Double getResult();
}

2、创建简单工厂类，OperationFactory

package com.wilson.calculator;

import com.wilson.calculator.operation.*;
import lombok.SneakyThrows;

/**
 * 工厂类 - 用于根据不同的运算符执行相对应的运算
 */
public class OperationFactory {

    @SneakyThrows
    public static Operation createOperation(String operation) {
        //利用多态，降低代码的耦合性
        Operation oper = null;
        switch (operation) {
            case "+":
                oper = new SumOperation();
                break;
            case "-":
                oper = new MinusOperation();
                break;
            case "*":
                oper = new MultiplyOperation();
                break;
            case "/":
                oper = new DivideOperation();
                break;
            default:
                throw new Exception("请输入正确的运算");
        }
        return oper;
    }
}

3、创建各种运算子类，进行不同的计算类型

加法类：

package com.wilson.calculator.operation;

/**
 * 加法运算
 */
public class SumOperation extends Operation {

    public SumOperation(Double firstNumber, Double secondNumber) {
        super(firstNumber, secondNumber);
    }

    public SumOperation() {

    }

    @Override
    public Double getResult() {
        return firstNumber + secondNumber;
    }
}

减法类：

package com.wilson.calculator.operation;

/**
 * 减法运算
 */
public class MinusOperation extends Operation{

    public MinusOperation(Double firstNumber, Double secondNumber) {
        super(firstNumber, secondNumber);
    }

    public MinusOperation() {

    }

    @Override
    public Double getResult() {
        return firstNumber - secondNumber;
    }
}

乘法类：

package com.wilson.calculator.operation;

/**
 * 乘法运算
 */
public class MultiplyOperation extends Operation{
    public MultiplyOperation(Double firstNumber, Double secondNumber) {
        super(firstNumber, secondNumber);
    }

    public MultiplyOperation() {

    }

    @Override
    public Double getResult() {
        return firstNumber * secondNumber;
    }

除法类：

package com.wilson.calculator.operation;

import lombok.SneakyThrows;

/**
 * 除法运算
 */
public class DivideOperation extends Operation {
    public DivideOperation(Double firstNumber, Double secondNumber) {
        super(firstNumber, secondNumber);
    }

    public DivideOperation() {

    }

    @SneakyThrows
    @Override
    public Double getResult() {
        if (secondNumber == 0) throw new Exception("除数不能为零");
        return firstNumber / secondNumber;
    }
}

4、主方法调用实现类

package com.wilson.calculator.operationinterface;

import com.wilson.calculator.OperationFactory;
import com.wilson.calculator.operation.Operation;

import java.util.Scanner;

public class Demo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入第一个数： ");
        Double firstNumber = scanner.nextDouble();
        System.out.println("请输入运算符  + - * / ");
        String operationMode = scanner.next();
        System.out.println("请输入第二个数： ");
        Double secondNumber = scanner.nextDouble();

        Operation operation = OperationFactory.createOperation(operationMode);
        operation.setFirstNumber(firstNumber);
        operation.setSecondNumber(secondNumber);
        Double result = operation.getResult();
        System.out.println("计算结果为： " + result);
    }
}

简单工厂方法的优缺点：
优点：

1、工厂类包含必要的逻辑判断，可以决定在什么时候创建哪一个产品的实例。客户端可以免除之间创建产品对象的职责；

2、客户端无需知道所创建的具体产品的类名，只需要知道参数即可；

3、也可以引入配置文件，在不修改客户端代码的情况下更换和添加具体的产品类。

缺点：

1、工厂类集中了所有产品的创建逻辑，职责过重，一旦出现异常，整个系统将受影响；

2、使用简单工厂模式会增加系统中类的个数（引入新的工长类），增加系统的复杂度和理解难度；

3、系统扩展困难，一旦增加新产品不得不修改工厂逻辑，在产品较多时，可能造成逻辑过于复杂；

4、简单工厂模式使用了static方法，造成工厂角色无法形成基于继承的等级结构。

使用场景：

1、工厂类创建对象比较少，因为不会造成工厂方法的业务逻辑过于复杂；

2、客户端只知道传入工厂类的参数，对如何创建按对象不关心