模式设计：简单工厂模式

近读《大话模式设计》一书，更感感受本身对软件设计方面一窍不通，实在是个“码农”。功过此书对软件工程等方面的基础知识有个简单的了解，在此将我的理解整理，备案。

简单工厂模式又称为静态工厂模式，是由一个工厂对象来肯定具体实例化哪一个产品实例。用户只需传入条件，工厂根据条件返回符合要求的产品实例。

例子：

根据用户的选择，进行加、减、乘、除运算。若是按照我原来的code习惯，应该是：

if ("+") {
  //没有任何返利
}
if ("-"){
  //
}
if ("*") {
  //  
}

此处的毛病就是对用户的一个状态，代码要进行屡次判断，并且每次返回不一样的数据都会彻底暴露给用户，没有作好数据的封装。若是：

switch("四则运算"){
case "+":
    ...
    break;
    
    case "-":
    ...
    break;
    
    case "*":
    ...
    break;
    ...
}

则会避免数据外泄。而且易于扩展。

实例：

//全部操做类的父类
public abstract class Operation {
    public Operation() {

    }

    public double getNumA() {
        return numA;
    }

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

    public double getNumB() {
        return numB;
    }

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

    public abstract double getResult();

    private double numA = 0;
    private double numB = 0;
}

/**
 * 加法类
 * */
class OperationAdd extends Operation {
    public OperationAdd() {
        super();
    }

    @Override
    public double getResult() {
        return (getNumA() + getNumB());
    }
}

/**
 * 减法类
 * */
class OperationSub extends Operation {
    public OperationSub() {
        super();
    }

    @Override
    public double getResult() {
        return (getNumA() - getNumB());
    }
}

/**
 * 乘法类
 * */
class OperationMul extends Operation {
    public OperationMul() {
        super();
    }

    @Override
    public double getResult() {
        return (getNumA() * getNumB());
    }
}

/**
 * 除法类，当除数为0时，返回值为0
 * */
class OperationDiv extends Operation {
    public OperationDiv() {
        super();
    }

    public double getResult() {
        if (getNumB() != 0) {
            return (getNumA() / getNumB());
        } else {
            return 0;
        }
    }
}

四则运算的标志集合：

enum OperatorCollection {
    ADD,
    SUB,
    MUL,
    DIV
}

具体工厂类：

public class OperationFactory {
    public static Operation createFactory(OperatorCollection oc) {
        Operation op = null;

        switch (oc) {
            case ADD:
                op = new OperationAdd();
                break;

            case SUB:
                op = new OperationSub();
                break;

            case MUL:
                op = new OperationMul();
                break;

            case DIV:
                op = new OperationDiv();
                break;
        }

        return op;
    }

    private OperationFactory() {

    }
}

main类：

public class ClientClass {
    public static void main(String[] args) {
        new ClientClass().operationFunction(20, 33, OperatorCollection.MUL);
    }

    private void operationFunction(double numA, double numB, OperatorCollection oc) {
        Operation op = OperationFactory.createFactory(oc);
        op.setNumA(numA);
        op.setNumB(numB);

        String operator = "";
        switch (oc) {
            case ADD:
                operator = " + ";
                break;

            case SUB:
                operator = " - ";
                break;

            case MUL:
                operator = " * ";
                break;

            case DIV:
                operator = " / ";
                break;
        }

        System.out.println(numA + operator + numB + " = " + op.getResult());
    }
}

只要输入数字和运算符号，直接就能够进行计算，并且数据也可封装。