简单工厂模式

一、定义：

简单工厂模式，是指通过一个类创建某一类型的实例，根据传入的参数不同，创建对应的实例。这些实例都有一个共同的父类。

二、特点：

将具体的业务逻辑分离封装，客户端只需通过工厂类，来创建所需的实例。后期维护时也只需维护具体的实现类，降低耦合性。利用了java的封装、继承、多态三大特性。

三、示例：提供四则运算的计算器代码

加减乘除四种算法都由四个算法类来实现，他们都继承了父类Operator。工厂类OperationFactory提供了创建这四种实例的方法,客户端通过它生成父类Operator来实现所需的计算。

UML图：

运算的父类：

package com.pattern.simpleFactory;
​
public class Operator {
    private String numberA;
    private String numberB;
​
    String printResult;
​
    public String getNumberA() {
        return numberA;
    }
​
    public void setNumberA(String numberA) {
        this.numberA = numberA;
    }
​
    public String getNumberB() {
        return numberB;
    }
​
    public void setNumberB(String numberB) {
        this.numberB = numberB;
    }
​
    public String  getResult(String operator){
​
            return printResult;
    }
}
​

加法运算：

package com.pattern.simpleFactory;
​
import java.text.DateFormat;
​
public class Addition extends Operator {
​
    public String getResult(String operator) {
        DateFormat.getDateInstance();
        Double result=Double.parseDouble(getNumberA())+Double.parseDouble(getNumberB());
        printResult=result.toString();
        return printResult;
​
    }
}
​

减法运算：

package com.pattern.simpleFactory;
​
public class Subtraction extends Operator {
    public String getResult(String operator) {
        Double result = Double.parseDouble(getNumberA()) - Double.parseDouble(getNumberB());
        printResult = result.toString();
        return printResult;
    }
​
}
​

乘法运算：

package com.pattern.simpleFactory;
​
public class Multiplication extends Operator{
​
    public String  getResult(String operator){
        Double result=Double.parseDouble(getNumberA())*Double.parseDouble(getNumberB());
        printResult=result.toString();
        return printResult;
    }
​
}
​

除法运算：

package com.pattern.simpleFactory;
​
public class Subtraction extends Operator {
    public String getResult(String operator) {
        Double result = Double.parseDouble(getNumberA()) - Double.parseDouble(getNumberB());
        printResult = result.toString();
        return printResult;
    }
}
​

工厂类：

package com.pattern.simpleFactory;
​
/*简单工厂模式*/
public class OperationFactory {
    Operator operator;
​
    public Operator getOperator(String opt) {
        switch (opt) {
            case "*":
                operator = new Multiplication();
                break;
            case "+":
                operator = new Addition();
                break;
            case "-":
                operator = new Subtraction();
                break;
            case "/":
                operator = new Division();
                break;
            default:
                break;
        }
        return operator;
    }
}
​

客户端代码：

package com.pattern.simpleFactory;
​
public class Client {
    public static void main(String[] args) {
        String numberA="23";
        String numberB="56";
        String opt="/";
        /*利用简单工厂生成实例*/
        Operator operator =new OperationFactory().getOperator(opt);
        operator.setNumberA(numberA);
        operator.setNumberB(numberB);
       String result =operator.getResult(opt);
        System.out.println(result);
​
    }
}
​