简单工厂模式

简单工厂模式

通过一个小需求来看一下简单工厂模式：
1. 项目需求：假设我们要一个加减乘除运算的功能，要求面向对象的方式，达到可维护、可复用、可扩展、灵活性好。
2. 需求分析：
      ①.为了达到高内聚低耦合的效果以及需求，可以考虑面向接口编程的思想，将共性抽取出去，因为是抽取类的共性，因此使用抽象类比较好。
      ②.首先创建运算类，提供运算方法的模板，为了不让模板实例化，因此仍然考虑到使用抽象类。
      ③.创建运算类的子类，再各子类中实现功能，这也是多态的体现。
      ④.创建工厂类，根据运算符号实例化对应的子类对象，通过多态返回父类的方式实现运算。
      ⑤.测试。
3. 类图如下：

4. 具体代码如下：

/**
 * Created by 杨Sir on 2017/11/12.
 * Operation 运算类
 */
public abstract class Operation {

    protected double number1;
    protected double number2;

    public double getNumber1() {
        return number1;
    }

    public void setNumber1(double number1) {
        this.number1 = number1;
    }

    public double getNumber2() {
        return number2;
    }

    public void setNumber2(double number2) {
        this.number2 = number2;
    }

    //实现计算的模板方法
    public abstract double getResult() throws Exception;
}

/**
 * Created by 杨Sir on 2017/11/12.
 * 加法类
 */
public class OperationAdd extends Operation{

    //加法
    @Override
    public double getResult() {

        double result = 0.0;
        result = number1 + number2;
        return result;
    }
}

/**
 * Created by 杨Sir on 2017/11/12.
 * 减法类
 */
public class OperationSub extends Operation{

    //实现减法运算
    @Override
    public double getResult() {
        double result = number1 - number2;
        return result;
    }
}

/**
 * Created by 杨Sir on 2017/11/12.
 * 乘法运算类
 */
public class OperationMul extends Operation{
    //定义乘法运算
    @Override
    public double getResult() throws Exception {

        double result = number1 * number2;
        return result;
    }
}

/**
 * Created by 杨Sir on 2017/11/12.
 * 除法类
 */
public class OperationDiv extends Operation{
    //除法运算
    @Override
    public double getResult() throws Exception {
        if(number2 == 0){
            throw new Exception("除数为零！");
        }
        double result = number1 / number2;

        return result;
    }
}

/**
 * Created by 杨Sir on 2017/11/12.
 * 运算工厂类
 */
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;
    }
}

/**
 * Created by 杨Sir on 2017/11/12.
 * 测试
 */
public class Mian {

    public static void main(String[] args) throws Exception {

        Operation operation = OperationFactory.createOperation("/");

        operation.number1 = 10;
        operation.number2 = 3;

        double result = operation.getResult();
        System.out.println(result);
    }
}

      当我们想要扩展运算的时候，只需继承运算模板类，然后在工厂方法的 switch语句中添加一个分支即可。简单工厂其实算不上是一个设计模式，但它就是非常容易理解、易用。
      简单来说，简单工厂就是定义一个工厂类，这个工厂类提供了创建具有共同接口的子类实例的方法，外界只要告诉工厂类需要什么类型的实例，工厂类就给他什么类型的实例，外部无需关心具体实现，从而达到接口隔离的目的。

对使用简单工厂的建议：
      ①. 工厂方法静态化。
      ②. 实例创建配置文件化：实例创建尽量通过配置文件及反射机制，动态创建。达到能根据某个值，自动判断并创建对应类的实例的目的，这样就可以将庞大的switch语句消除，同时，实例化部分的修改，只需要修改配置即可。
      ③. 简单工厂模块化：也就是遵守单一职责原则，一个工厂类只包含一个工厂方法，该工厂方法只创建同一个接口的子类对象。不同的功能模块，创建不同的工厂类。