简单易懂设计模式——简单工厂模式

一.简单工厂

将不同的算法用不同的类实现，在工厂类中实例化需要的类返回给客户端，客户端只需要与工厂类打交道就行，不需要知道具体的算法类。

工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式。著名的Jive论坛 ,就大量使用了工厂模式，工厂模式在Java程序系统可以说是随处可见。因为工厂模式就相当于创建实例对象的new，我们经常要根据类Class生成实例对象，如A a=new A() 工厂模式也是用来创建实例对象的，所以以后new时就要多个心眼，是否可以考虑使用工厂模式，虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量。

 

二.UML图

三.一个计算器例子

package simpleFactory;
public class Operation {
       private double result = 0;
       private double double_numberA = 0;
       private double double_numberB = 0;
       public double getDouble_numberA() {
             return double_numberA;
       }
       public void setDouble_numberA(double double_numberA) {
             this.double_numberA = double_numberA;
       }
       public double getDouble_numberB() {
             return double_numberB;
       }
       public void setDouble_numberB(double double_numberB) {
             this.double_numberB = double_numberB;
       }
       
       public double getResult() {
             return result;
       }
}

package simpleFactory;
public class OperationAdd extends Operation{
       @Override
       public double getResult() {
             return getDouble_numberA() + getDouble_numberB();
       }
}

package simpleFactory;
public class OperationSub extends Operation{
       private double result;
       @Override
       public double getResult() {
             result = getDouble_numberA() - getDouble_numberB();
             return result;
       }
}

package simpleFactory;
public class OperationMul extends Operation{
       private double result;
       @Override
       public double getResult() {
             result = getDouble_numberA() * getDouble_numberB();
             return result;
       }
}

package simpleFactory;
public class OperationDiv extends Operation{
       private double result;
       @Override
       public double getResult() {
             if (getDouble_numberB() == 0)
                    try {
                           throw new Exception("除数不能为0.");
                    } catch (Exception e) {
                           e.printStackTrace();
                    }
             result = getDouble_numberA() / getDouble_numberB();
             return result;
       }
}

package simpleFactory;
public class OperationFactory {
       public static Operation createOperate(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;
       }
}

package simpleFactory;
public class Client {
       public static void main(String[] args) {
             Operation oper  = OperationFactory.createOperate("+");
             oper.setDouble_numberA(1);
             oper.setDouble_numberB(2);
             double result = oper.getResult();
             System.out.println(result);
       }
}

 四.优缺点

优点：
工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象.通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责“消费”对象就可以了。而不必管这些对象究竟如何创建及如何组织的．明确了各自的职责和权利，有利于整个软件体系结构的优化。
缺点：
由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。
当系统中的具体产品类不断增多时候，可能会出现要求工厂类根据不同条件创建不同实例的需求．这种对条件的判断和对具体产品类型的判断交错在一起，很难避免模块功能的蔓延，对系统的维护和扩展非常不利；

五.使用场景

工厂类负责创建的对象比较少；
客户只知道传入工厂类的参数，对于如何创建对象（逻辑）不关心；
由于简单工厂很容易违反高内聚责任分配原则，因此一般只在很简单的情况下应用。

转载于:https://www.cnblogs.com/wuwuyong/p/9850295.html