简单工厂模式和工厂方法模式的区别

本文举了一个计算器的例子，该例子实现的功能是加减乘除的功能。
简单工厂模式：就是如何去实例化对象的问题，对于很容易变化的问题，应该考虑用一个单独的类来做这个创造实例的过程，这就是工厂。例子如下：

package com.factory;
public class Operation {
    private double numberA = 0;
    private double numberB = 0;
    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() {
        double result = 0;
        return result;
    }
}
package com.factory;
/**
 * 加法
 * @author Administrator
 *
 */
public class OperationAdd extends Operation{
    @Override
    public double getResult() {
        double result = 0;
        result = getNumberA() + getNumberB();
        return result;
    }
}
/**
 * 减法
 * @author Administrator
 *
 */
public class OperationSub extends Operation{
    @Override
    public double getResult() {
        double result = 0;
        result = getNumberA() - getNumberB();
        return result;
    }
}

/**
 * 乘法
 * @author Administrator
 *
 */
public class OperationMul extends Operation{
    @Override
    public double getResult() {
        double result = 0;
        result = getNumberA() * getNumberB();
        return result;
    }
}

/**
 * 除法
 * @author Administrator
 *
 */
public class OperationDiv extends Operation{
    @Override
    public double getResult() {
        double result = 0;
            try {
                if (0 == getNumberB()){
                    throw new Exception("除数不能为0");
                }
            } catch (Exception e) {
                e.printStackTrace();
        }
        result = getNumberA() / getNumberB();
        return result;
    }
}

/**
 *  简单运算工厂类
 * @author Administrator
 *
 */
public class OperrateFactory {
    public static Operation createOperate(String operate) {
        Operation oper = null;
        if (operate.equals("+")) {
            oper = new OperationAdd();
        } else if (operate.equals("-")) {
            oper = new OperationSub();
        } else if (operate.equals("*")) {
            oper = new OperationMul();
        } else if (operate.equals("/")) {
            oper = new OperationDiv();
        }
        return oper;
    }
}

在这个例子中，只需要输入运算符，工厂就实例化出合适的对象，通过多态返回父类的方式实现了计算器的结果。而客户端只要这样调用就可以了，如下：

    Operation operation ;
//      operation = OperrateFactory.createOperate("+");
//      operation = OperrateFactory.createOperate("-");
//      operation = OperrateFactory.createOperate("*");
        operation = OperrateFactory.createOperate("/");
        operation.setNumberA(1);
        operation.setNumberB(2);
        System.out.println(operation.getResult());

而使用工厂方法模式实现的话，那就要先创建一个工厂接口，然后加减乘除各建一个工厂方法去实现这个接口。例子如下：

/**
 * 工厂接口
 * @author Administrator
 *
 */
public interface IFactory {
    Operation createOperation();
}
/**
 * 加法
 * @author Administrator
 *
 */
public class AddFactory implements IFactory{
    @Override
    public Operation createOperation() {
        return new OperationAdd();
    }
}
/**
 * 除法
 * @author Administrator
 *
 */
public class DivFactory implements IFactory{
    @Override
    public Operation createOperation() {
        return new OperationDiv();
    }
}
/**
 * 乘法
 * @author Administrator
 *
 */
public class MulFactory implements IFactory{
    @Override
    public Operation createOperation() {
        return new OperationMul();
    }
}
/**
 * 减法
 * @author Administrator
 *
 */
public class SubFactory implements IFactory{
    @Override
    public Operation createOperation() {
        return new OperationSub();
    }

}
客户端实现：
        IFactory factory = new AddFactory();
        Operation operation = factory.createOperation();
        operation.setNumberA(1);
        operation.setNumberB(2);
        System.out.println(operation.getResult());

1.简单工厂和工厂方法的区别：简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。
就像这个计算器，让客户端不用管该用哪个类的实例，只需要把“+”给工厂，工厂自动就给出了相应的实例，客户端只要去运算就可以了，不同的实例会实现不同的运算。
2.工厂模式方法（factory method），定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到子类。
3.工厂方法模式实现时，客户端需要决定实例化哪一个工厂来实现运算类，选择判断的问题还是存在的，也就是说，工厂方法把简单工厂的内部逻辑判断移到了客户端代码来进行。你想要加功能，本来是要改工厂类的，而现在是修改客户端。
4.工厂方法克服了简单工厂违背开放-封闭原则的缺点，又保持了封装对象创建过程的优点。这两者都是集中封装了对象的创建，使得要更换对象时，不需要做大的改动就可实现，降低了客户程序与产品对象的耦合。工厂方法模式是简单工厂模式的进一步抽象和推广。由于使用了多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。但缺点是由于每加一个产品，就需要加一个产品工厂的类，增加了额外的开发量。