Java设计模式篇（三）--简单工厂模式详解

在说简单工厂模式之前，我们先来了解下活字印刷术。

古时候没有现在这么现代化，都是先刻好印版，然后用印版将文章去印在纸上。每写一篇，都得刻一版，好累。

毕昇，是个头脑很灵活的工匠，他就在想，如果我把每个字都单独刻出来，你用的时候自己去组合，这样不就省事了，因此，一项伟大的发明就出现了---活字印刷术。

活字印刷术有4大特点：

第一，要改文章的字，只需要替换对应的字模就行，这是可维护。

第二，每个字模可以多次使用，这是可复用。

第三，如果文章中用到的字没有，可以新刻一个对应的字，这是可扩展。

第四，如果想改变文章的排版，只需要改变字模的方向就行，灵活性好。

我们在开发中，经常遇到用户改需求的时候，你是否很累？我们用了这么多年面向对象编程语言，多态，继承等降低了程序之间的耦合，但是一种好的组织形式是必不可少的，让你有章可循，这就是我们的设计模式。

在设计过程中，我们要将业务逻辑和系统逻辑分离开来，这样就不会因为业务需求的变动，而各种痛苦不堪。

我们先来一例，了解下简单工厂模式。

一、简单工厂模式

现在有一个需求，让你设计一个计算器。你怎么做？

首先我们知道，计算器中包含最基本的加减乘除，参与运算的是两个数值，一个运算符，一个结果，如1+1=2。

很多人说这个很简单，然后将一堆代码写在一个方法中，各种条件判断。如果我后期要新增或者修改呢？比如我要新增一个开根运算，你怎么办？继续在原有客户端方法中新增分支？要是改错了怎么办？系统立马就不能用了。这种的就是典型的紧耦合，典型的面向对象过程编程，我们要像毕昇学习，用活字印刷版的思路去做。

大多数人，碰到问题就直觉的按照计算机能够理解的逻辑去做开发，而没有真正的做到面向对象。

面向对象编程的三大特性：继承，封装，多态。封装，大多数人都有意识，可是多态这个利器却没有用起来。

我们说过，类是具有一组相同行为和属性的对象的抽象，分类的目的是为了封装。但是如果涉及到的类的

具有相同的行为，只是实现不一样，那就使用接口。如果涉及到的类具有相同的属性和行为，只是行为的实现不一样，那么就使用继承。

根据多态的特性，利用父类可以去代表子类，对外，可以统一使用父类去做操作。这里，我们的计算器操作需要两个数，行为相同实现不一样，因此可以使用继承实现多态。这样，我们的类图就有了。

我们先创建这几个类：

package com.zhaodf.pattern.simpleFactory;

public interface Operation {

    double getResult();
}

package com.zhaodf.pattern.simpleFactory;

public class OperationAdd implements Operation{
    private double numberA;
    private double numberB;

    public OperationAdd(double numberA,double numberB){
        this.numberA = numberA;
        this.numberB = numberB;
    }

    public double getResult() {
        return this.numberA+this.numberB;
    }

    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;
    }
}

package com.zhaodf.pattern.simpleFactory;

public class OperationDiv implements Operation{
    private double numberA;
    private double numberB;

    public OperationDiv(double numberA, double numberB){
        this.numberA = numberA;
        this.numberB = numberB;
    }

    public double getResult() {
        if(this.numberB==0){
            System.out.println("除数不能为0");
            return 0;
        }
        return this.numberA / this.numberB;
    }

    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;
    }
}

package com.zhaodf.pattern.simpleFactory;

public class OperationMul implements Operation{
    private double numberA;
    private double numberB;

    public OperationMul(double numberA, double numberB){
        this.numberA = numberA;
        this.numberB = numberB;
    }

    public double getResult() {
        return this.numberA * this.numberB;
    }

    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;
    }
}

package com.zhaodf.pattern.simpleFactory;

public class OperationSub implements Operation{
    private double numberA;
    private double numberB;

    public OperationSub(double numberA, double numberB){
        this.numberA = numberA;
        this.numberB = numberB;
    }

    public double getResult() {
        return this.numberA - this.numberB;
    }

    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;
    }
}

 基本类创建完了，我们现在需要一个根据计算要求统一生产这些类的地方---工厂，并且，我们使用父类作为统一对外的窗口，使客户端调用过程透明。

我们的工厂类如下：

package com.zhaodf.pattern.simpleFactory;

public class OperationFactory{
    //我们用1-代表加法，2-代表减法，3-代表乘法，4-代表除法
    public static Operation createOperation(double numberA,double numberB,int operationType){
        Operation op = null;
        switch (operationType){
            case 1:
                op = new OperationAdd(numberA,numberB);
                break;
            case 2:
                op = new OperationSub(numberA,numberB);
                break;
            case 3:
                op = new OperationMul(numberA,numberB);
                break;
            case 4:
                op = new OperationDiv(numberA,numberB);
                break;
        }
        return op;
    }
}

客户端调用代码：

package com.zhaodf.pattern.simpleFactory;

public class TestOperation {
    public static void main(String[] args){
        double numberA = 1;
        double numberB = 2;
        Operation op = OperationFactory.createOperation(numberA,numberB,1);
        System.out.println(op.getResult());
    }
}

二、总结

简单工厂模式，将创建运算对象过程放在了工厂类中，并且使用面向对象编程的特性-多态，将运算对象的父类作为统一对外的窗口。这里也有个不好的地方，就是虽然简化了客户端的代码，但是工厂类中创建对象的分支也需要维护，后面我们讲到反射时，再来修改此处。