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

一.简单工厂

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

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

二.一个计算器例子

1.提供Operation运算类为其他类继承

package factory;

/**
 * 运算类
 * @author wuwuyong
 *
 */
public class Operation {
    
    private double _numberA = 0;
    private double _numberB = 0;
    
    public double get_numberA() {
        return _numberA;
    }
    public void set_numberA(double _numberA) {
        this._numberA = _numberA;
    }
    public double get_numberB() {
        return _numberB;
    }
    public void set_numberB(double _numberB) {
        this._numberB = _numberB;
    }
    
    public double GetResult() {
        double result = 0;
        return result;
    }

}

2.加法类继承Operation

package factory;

/**
 * 加法
 * @author wuwuyong
 *
 */
public class OperationAdd extends Operation {

    @Override
    public double GetResult() {
        double result = 0;
        result = get_numberA() + get_numberB();
        return  result;
    }
}

3.减法类继承Operation

package factory;

/**
 * 减法
 * @author wuwuyong
 *
 */
public class OperationSub extends Operation {

    @Override
    public double GetResult() {
        double result = 0;
        result = get_numberA() - get_numberB();
        return  result;
    }
}

4.乘法类继承Operation

package factory;

/**
 * 乘法
 * @author wuwuyong
 *
 */
public class OperationMul extends Operation {

    @Override
    public double GetResult() {
        double result = 0;
        result = get_numberA() * get_numberB();
        return  result;
    }
}

5.除法类继承Operation

package factory;

/**
 * 除法
 * @author wuwuyong
 *
 */
public class OperationDiv extends Operation {

    @Override
    public double GetResult() {
        double result = 0;
        if (get_numberB() == 0) {
            try {
                throw new Exception("除数不能为0。");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        result = get_numberA() / get_numberB();
        return  result;
    }
}

6.工厂类

package factory;

/**
 * 工厂类
 * @author wuwuyong
 *
 */
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;
    }
}

7.测试

package factory;

/**
 * 测试
 * @author wuwuyong
 *
 */
public class Test {

    public static void main(String[] args) {
        Operation oper;
        oper = OperationFactory.createOperate("+");
        oper.set_numberA(222);
        oper.set_numberB(444);
        double result = oper.GetResult();
        System.out.println("加法结果："+result);
    }
}

三.UML图

 四.优缺点

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

五.使用场景

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