7. 对象创建——简单工厂

“对象创建” 模式

• 通过 “对象创建” 模式绕开 new，来避免 new 导致的紧耦合（依赖具体类），从而支持对象创建的稳定。它是接口抽象之后的第一步工作。
• 典型模式：
  • 简单工厂模式
  • Factory Method
  • Abstract Factory
  • Propotype
  • Builder

一、代码示例

**背景：**假设我们要实现一个计算器，包括加减乘除

我们为了将计算逻辑与界面逻辑分开，可以这样写：

import java.util.Scanner;

class Operation {
    public static double getResult(double numA, double numB, String operate) {
        double result = 0;

        switch (operate) {
            case "+":
                result = numA + numB;
                break;
            case "-":
                result = numA - numB;
                break;
            case "*":
                result = numA * numB;
                break;
            case "/":
                result = numA / numB;
                break;
            default:
                break;
        }

        return result;
    }
}

class Client {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("输入数字A：");
        String strNumA = sc.nextLine();

        System.out.println("输入运算符号：");
        String operation = sc.nextLine();

        System.out.println("输入数字B：");
        String strNumB = sc.nextLine();

        double result = Operation.getResult(Double.parseDouble(strNumA), Double.parseDouble(strNumB), operation);

        System.out.println("结果是" + result);
    }
}

**需求变更：**此时，我们需要新添加一个运算符，取余运算。

依据上面的实现方法，我们可以直接在Operation里新添加一个switch分支，但是这样导致的问题是如果频繁地添加运算符，就会频繁地修改Operation类，很容易在添加代码的时候将原有的代码改变。

**分析：**其实，上面的实现方式违反了开放封闭原则，我们要使用一种结构，使得可以在不修改原有代码的基础上增加功能。

abstract class Operation {
    protected double numA;
    protected double numB;

    public void setNumA(double numA) {
        this.numA = numA;
    }

    public void setNumB(double numB) {
        this.numB = numB;
    }

    public abstract double getResult();
}

class OperationAdd extends Operation {
    public double getResult() {
        return numA + numB;
    }
}

class OperationSub extends Operation {
    public double getResult() {
        return numA - numB;
    }
}

class OperationMul extends Operation {
    public double getResult() {
        return numA * numB;
    }
}

class OperationDiv extends Operation {
    public double getResult() {
        return numA * numB;
    }
}

此时，如果需要新增加运算符，只需要新建一个类继承自Operation即可。

但是，我们现在又面临了一个新的问题，即该如何创建运算类，此时就引出了简单工厂模式：

class SimpleFactory {
    public Operation getOperation(String operate) {
        Operation operation;
        switch(operate) {
            case "+":
                operation = new OperationAdd();
                break;
            case "-":
                operation = new OperationSub();
                break;
            case "*":
                operation = new OperationMul();
                break;
            case "/":
                operation = new OperationDiv();
                break;
            default:
                operation = null;
                break;
        }

        return operation;
    }
}

class Client {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        SimpleFactory simpleFactory = new SimpleFactory();

        System.out.println("输入数字A：");
        String strNumA = sc.nextLine();

        System.out.println("输入运算符号：");
        String operate = sc.nextLine();

        System.out.println("输入数字B：");
        String strNumB = sc.nextLine();

        Operation operation = simpleFactory.getOperation(operate);
        operation.setNumA(Double.parseDouble(strNumA));
        operation.setNumB(Double.parseDouble(strNumB));

        double result = operation.getResult();

        System.out.println("结果是" + result);
    }
}

此时，对于客户端来说，业务层使用的是什么计算逻辑是无感知的，就可以动态的添加运算符了，这就是简单工厂模式。