一、定义

工厂方法模式，定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。

需求：设计个计算器，两个数字之间的加减乘除基本运算。

IFactory.java

package com.FactoryMethod;

import com.SimpleFactory.Operation;

/**
 * 工厂方法模式
 *
 * @Description: 工厂接口
 * 
 */
public interface IFactory {
    public Operation createOperation();
}

AddFactory.java

package com.FactoryMethod;

import com.SimpleFactory.Operation;
import com.SimpleFactory.OperationAdd;

/**
 * 工厂方法模式
 *
 * @Description: 加法工厂
 * @Date 2018/7/27
 */
public class AddFactory implements IFactory {
    @Override
    public Operation createOperation() {
        return new OperationAdd();
    }
}

SubFactory.java

package com.FactoryMethod;

import com.SimpleFactory.Operation;
import com.SimpleFactory.OperationSub;

/**
 * 工厂方法模式
 *
 * @Description: 减法工厂
 * @Date 2018/7/27
 */
public class SubFactory implements IFactory {
    @Override
    public Operation createOperation() {
        return new OperationSub();
    }
}

MulFactory.java

package com.FactoryMethod;

import com.SimpleFactory.Operation;
import com.SimpleFactory.OperationMul;

/**
 * 工厂方法模式
 *
 * @Description: 乘法工厂
 * @Date 2018/7/27
 */
public class MulFactory implements IFactory {
    @Override
    public Operation createOperation() {
        return new OperationMul();
    }
}

DivFactory.java

package com.FactoryMethod;

import com.SimpleFactory.Operation;
import com.SimpleFactory.OperationDiv;

/**
 * 工厂方法模式
 *
 * @Description: 除法工厂
 * @Date 2018/7/27
 */
public class DivFactory implements IFactory {
    @Override
    public Operation createOperation() {
        return new OperationDiv();
    }
}

测试方法类Test：

package com.FactoryMethod;

import com.SimpleFactory.Operation;

/**
 * 工厂方法模式
 *
 * @Description: 工厂方法模式测试
 * @Date 2018/7/27
 */
public class Test {
    public static void main(String[] args) {

        IFactory factory = new AddFactory();
        Operation oper = factory.createOperation();
        oper.number1 = 1;
        oper.number2 = 2;
        try {
            System.out.println(oper.getResult() + "");
        } catch (Exception e) {
            e.printStackTrace();
        }

        IFactory factory1 = new SubFactory();
        Operation oper1 = factory1.createOperation();
        oper1.number1 = 1;
        oper1.number2 = 2;
        try {
            System.out.println(oper1.getResult() + "");
        } catch (Exception e) {
            e.printStackTrace();
        }

        IFactory factory2 = new MulFactory();
        Operation oper2 = factory2.createOperation();
        oper2.number1 = 1;
        oper2.number2 = 2;
        try {
            System.out.println(oper2.getResult() + "");
        } catch (Exception e) {
            e.printStackTrace();
        }

        IFactory factory3 = new DivFactory();
        Operation oper3 = factory3.createOperation();
        oper3.number1 = 1;
        oper3.number2 = 2;
        try {
            System.out.println(oper3.getResult() + "");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

二、总结

1、与简单工厂模式比较
简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态的实例化相关的类，对于客户端来说，去除了与具体产品的依赖。当需要增加一个功能，如：求一个数的N次方时，不但要增加相应的运算类，也要在运算工厂类的方法里加“case的分支条件”，修改原有的类，这不但对扩展开放，也对修改开放了，违背了“开放-封闭原则”。
而使用工厂方法模式，增加一个功能，只需要增加相应的运算类，不需要修改原有的类，符合“开放-封闭原则”，但是需要修改客户端的代码，它将简单工厂的内部逻辑判断移到了客户端代码来进行。
2、工厂方法的优点
工厂方法克服了简单工厂违背“开放-封闭原则”的缺点，又保持了封装对象创建过程的优点，降低了客户端程序与产品对象的耦合。工厂方法模式是简单工厂模式的进一步抽象和推广。

工厂模式--工厂方法模式