简单工厂模式

• 1.简单工厂模式的实质

  简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。

• 2.画上流程框图

  

• 3.面向对象三大特性

  这里为什么再把继承、封装、多态搬到台面上来呢？因为工厂模式离不开他呀！这几个家伙太重要了！

  封装：只要你把业务和判断逻辑分别写成方法就算是封装了，这样就是实现了可维护性和复用性，当你想修改业务时候就去修改业务的方法即可。
  继承：子类继承父类，提高扩展性（当你想增加一个取余数运算时，加个子类即可）
  多态：[同一个行为具有不同的表现形态]，当你明白了向上转型你就理解了工厂类(https://blog.csdn.net/qq_31655965/article/details/54746235)
  

• 4.贴上代码类

• Operation类（父类）

package SimpleFactory;

public class Operation {
    private double numberA;
    private double numberB;

    public double getNumberA() {
        return numberA;
    }

    public void setNumberA(double numberA) {
        this.numberA = numberA;
    }

    public double getNumberB() {
        return numberB;
    }

    public void setNumberB(double numberB) {
        this.numberB = numberB;
    }

    public double GetResult() {
        return 0;
    }
}

• 运算符类（子类：加减乘除）

package SimpleFactory;

public class Add extends Operation{

    @Override
    public double GetResult() {
        // TODO Auto-generated method stub
        return getNumberA()+getNumberB();
    }

}

package SimpleFactory;

public class Sub extends Operation {

    @Override
    public double GetResult() {
        // TODO Auto-generated method stub
        return getNumberA()-getNumberB();
    }

}

package SimpleFactory;

public class Mul extends Operation {

    @Override
    public double GetResult() {
        // TODO Auto-generated method stub
        return getNumberA()*getNumberB();
    }


}

package SimpleFactory;

public class Div extends Operation{

    @Override
    public double GetResult() {
        // TODO Auto-generated method stub
        if (getNumberB()==0) {
            try {
                throw new Exception("除数不能为0");
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return getNumberA()/getNumberB();
    }

}

• OperationFactory类（工厂类）

package SimpleFactory;

public class OperationFactory {
    public static Operation creatrOperation(String operation) {
        Operation oper = null;
        switch (operation) {
        case "+":
            oper = new Add();
            break;
        case "-":
            oper = new Sub();
            break;
        case "*":
            oper = new Mul();
            break;
        case "/":
            oper = new Div();
            break;
        default:
            System.err.println("请按照要求输入运算符号！");
            break;
        }
        return oper;
    }
}

• Service客户端类（测试类）

package SimpleFactory;

import org.junit.Test;

/**
 * 客户端类
 * @author Halo
 *
 */
public class Service {
    @Test
    public void testSimpleFactory() {
        Operation oper =null;
        oper = OperationFactory.creatrOperation("+");
        oper.setNumberA(1);
        oper.setNumberB(2);
        System.out.println(oper.GetResult());

        oper = OperationFactory.creatrOperation("-");
        oper.setNumberA(1);
        oper.setNumberB(2);
        System.out.println(oper.GetResult());

        oper = OperationFactory.creatrOperation("*");
        oper.setNumberA(1);
        oper.setNumberB(2);
        System.out.println(oper.GetResult());

        oper = OperationFactory.creatrOperation("/");
        oper.setNumberA(1);
        oper.setNumberB(2);
        System.out.println(oper.GetResult());

//      oper = OperationFactory.creatrOperation("swith里没有的运算符，如sqrt");
//      oper.setNumberA(1);
//      oper.setNumberB(2);
//      System.out.println(oper.GetResult());

        oper = OperationFactory.creatrOperation("/");
        oper.setNumberA(1);
        oper.setNumberB(0);
        System.out.println(oper.GetResult());
    }
}

5.浅析优劣

简单工厂模式，将变化的地方，用一个类表示，当需要使用，修改，删除这个变化的地方的时候，只需要创建，修改，删除指定类实例化对象即可。

优点：
工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象。通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责“消费”的对象就可以了。而不必管这些对象究竟如何创建及如何组织的．明确了各自的职责和权利，有利于整个软件体系结构的优化。

缺点：
由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。
当系统中的具体产品类不断增多时候，可能会出现要求工厂类根据不同条件创建不同实例的需求，这种对条件的判断和对具体产品类型的判断交错在一起，很难避免模块功能的蔓延，对系统的维护和扩展非常不利。

总之，
1. 维护性：维护时候只需要该类的实例就行了，简单粗暴！
2. 扩展性：需要增加其他的运算符时，只需要创建对应的类，再实例化，不过需要在工厂类中添加一段条件代码，表示何种条件下调用，这点不太友好！
3. 复用性：用多少次都ok，只要实例化对象即可。