设计模式之 各种工厂

再不济，工厂模式总是听过的吧，所以概念就不过多介绍了。
工厂模式一般分为工厂方法模式和抽象工厂模式。
好，上代码。

//定义一个接口
public interface ICalculator {
    int calculate(int a, int b);
}

//减法实现
public class CalculatorMinus implements ICalculator {
    @Override
    public int calculate(int a, int b) {
        return a - b;
    }
}

//加法实现
public class CalculatorPlus implements ICalculator {

    @Override
    public int calculate(int a, int b) {
        return a + b;
    }
}

工厂方法模式

public class NormalFactory {

    private NormalFactory() {
    }

    public enum CalculatorType {
        MINUS, PLUS
    }

    //    第一种形式
    public static ICalculator getInstance(CalculatorType type) {

        switch (type) {
            case PLUS:
                return new CalculatorPlus();
            case MINUS:
                return new CalculatorMinus();
            default:
                return null;
        }
    }

    //    第二种形式
    public static ICalculator getCalculatorPlus() {
        return new CalculatorPlus();
    }
    //    第二种形式
    public static ICalculator getCalculatorMinus() {
        return new CalculatorMinus();
    }
}

//调用代码省略不写了

不论NormalFactory 是否以静态方法的形式，也不论生产对象的方法是一个还是多个，本质上都没有区别。

抽象工厂

关于Calculator的代码保持不变，在生产对象的工厂上做点文章。

public interface ICalculatorProvider {
    ICalculator getCalculator();
}

CalculatorMinus和CalculatorPlus都有各自专门的生产对象的工厂。
大致就是这样的。

public class CalculatorMinusProvider implements ICalculatorProvider {
    @Override
    public ICalculator getCalculator() {
        return new CalculatorMinus();
    }
}

public class CalculatorPlusProvider implements ICalculatorProvider {
    @Override
    public ICalculator getCalculator() {
        return new CalculatorPlus();
    }
}

怎么用？

int a = 10, b = 5;
ICalculatorProvider calculatorProvider = null;
//加法
calculatorProvider = new CalculatorPlusProvider();
ICalculator calculatorPlus = calculatorProvider .getCalculator();
LogTool.e("CalculatorPlusProvider -->" + a + "+" + b + " = " + calculatorPlus.calculate(a, b));
//减法
calculatorProvider = new CalculatorMinusProvider();
ICalculator calculatorMinus = calculatorProvider .getCalculator();
LogTool.e("CalculatorMinusProvider -->" + a + "-" + b + " = " + calculatorMinus.calculate(a, b));

区别在哪里

这就不得不提到一个老鸟经常拿来装x的概念，开闭原则，意思就是说，在需要对程序进行扩展的时候不要轻易修改已有代码，要尽量把这种改动转换为横向添加。
举例子，如果现在需要增加一个除法，CalculatorDivision。
抽象工厂模式，定义一个CalculatorDivision实现ICalculator，再定义一个CalculatorDivisionProvider实现ICalculatorProvider即可，对已有的CalculatorPlus和CalculatorMinus全然没有影响。反观工厂方法模式呢，NormalFactory肯定是会被修改的，这就违反了开闭原则。
话说回来，使用抽象工厂模式，代码量会增加一些，直观性上稍稍差一点。所以，两者如何选择还是得“具体问题具体分析”了。