Base Time-Design Patterns-Factory Method

Base 2017-01

需求

• 请写一个计算加减乘除的简单程序。

面向过程

这个需求很简单，我们随手写个类，里面给个方法即可。

Calculator.java

public class Calculator {
    public float execute(float x, float y, String operation) {
        if (TextUtils.isEmpty(operation))
            return 0;
        float result;
        if ("+".equals(operation)) {
            result = x + y;
        } else if ("-".equals(operation)) {
            result = x - y;
        } else if ("*".equals(operation)) {
            result = x * y;
        } else if ("/".equals(operation)) {
            if (y == 0)
                result = 0;
            else
                result = x / y;
        } else {
            result = 0;
        }
        return result;
    }
}

上面的程序将计算器的代码封装到一个方法中，供客户端调用，这样如果存在多个客户端，只需要调用这个方法即可，实现了代码的可复用。那么现在我们把这个工具类编译后，其他人就可以使用了，假如说现在需要添加一个新算法，求A的B次方，我们就需要修改这个类的源代码，在getResult中加入新的分支，然后重新编译，供客户端使用，难扩展。

静态工厂方法

为了解决上面的问题，我们尝试用静态工厂方法去重构。

UML类图：

源代码：

接口Operation.java

public interface Operation {
    float execute(float x, float y);
}

实现Operation.java的具体实现子类
AddOperation.java

public class AddOperation implements Operation {
    @Override
    public float execute(float x, float y) {
        return x + y;
    }
}

SubOperation.java

public class SubOperation implements Operation {
    @Override
    public float execute(float x, float y) {
        return x - y;
    }
}

MultipleOperation.java

public class MultipleOperation implements Operation {
    @Override
    public float execute(float x, float y) {
        return x * y;
    }
}

DivOperation.java

public class DivOperation implements Operation {
    @Override
    public float execute(float x, float y) {
        return x / y;
    }
}

如果以后想增加中算法，那么只新增算法实现类，并继承接口Operation.java即可，无须修改其他的算法类。

接下来就是静态工程类的实现。
OperationFactory.java

public class OperationFactory {
    public static Operation createOperation(String op) {
        if (TextUtils.isEmpty(op))
            return null;
        Operation operation;
        if ("+".equals(op)) {
            operation = new AddOperation();
        } else if ("-".equals(op)) {
            operation = new SubOperation();
        } else if ("*".equals(op)) {
            operation = new MultipleOperation();
        } else if ("/".equals(op)) {
            operation = new DivOperation();
        } else {
            operation = null;
        }
        return operation;
    }
}

最后看一下TestCase.java

public class TestCase {
    public static void main(String[] args) {
        float x = 3;
        float y = 4;
        String operation = "-";
        Operation o = OperationFactory.createOperation(operation);
        if (o != null) {
            o.execute(x, y);
        } else {
            Log.e("factory", "Operation illegal");
        }
    }
}

小结

将创建对象的工作交给工厂负责，这样调用者不再和算法直接接触，有效的将使用和实现隔离开，并做到了可复用、可维护、可扩展。

我们知道面向对象有10大设计原则，其中之一是开闭原则

即对扩展开放，对修改关闭。这是另一种非常棒的设计原则，可以防止其他人更改已经测试好的代码。理论上，可以在不修改原有的模块的基础上，扩展功能。这也是开闭原则的宗旨。

如果现在有个需求，增加一种算法实现，那么不得不修改静态工厂类，并在createOperation()方法处新增一种算法的实例，很显然违背了上面的开闭原则，那么应该怎么解决这个问题呢，我们来看下面一篇博文Base Time-Design Patterns-Abstract Factory Method

参考博文：
简单工厂模式 参考和部分修改，特此说明。