Java设计模式 - 简单工厂模式

简单工厂模式是属于创建型模式,又叫做静态工厂方法(Static Factory Method)模式,但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式,可以理解为是不同工厂模式的一个特殊实现。-- 百度百科

原理说明

简单工厂模式的实质是由一个工厂类根据传入的参数,动态决定应该创建哪一个产品类的实例。

理论是不是理解起来有些抽象、有些似懂非懂呢?别担心,小编今天就来带大家从实践去理解理论。

今天小编准备用Java写一个小例子(计算工厂 - 加减乘除四则运算),加深下各位对简单工厂模式的理解。先上车,后面解释~

1.首先我们先来一个计算操作的抽象类Operation

/**
 * @ClassName: Operation
 * @Description: 计算操作 - 抽象类
 * @Author Wangnan
 * @Date 2016/8/17
 */
public abstract class Operation {

    private float numberOne; // 数字1
    private float numberTwo; // 数字2

    public float getNumberOne() {
        return numberOne;
    }

    public void setNumberOne(float numberOne) {
        this.numberOne = numberOne;
    }

    public float getNumberTwo() {
        return numberTwo;
    }

    public void setNumberTwo(float numberTwo) {
        this.numberTwo = numberTwo;
    }

    /**
     * 计算获取结果
     */
    public abstract float getResult();
}

2.然后,我们给出四则运算的实现类。加法、减法、乘法的实现类基本一致,除法的实现类需添加异常判断(除0异常)。

/**
 * @ClassName: OperationAdd
 * @Description: 加法操作实现类
 * @Author Wangnan
 * @Date 2016/8/17
 */
public class OperationAdd extends Operation {

    @Override
    public float getResult() {
        return getNumberOne() + getNumberTwo();
    }
}

/**
 * @ClassName: OperationSub
 * @Description: 减法操作实现类
 * @Author Wangnan
 * @Date 2016/8/17
 */
public class OperationSub extends Operation{

    @Override
    public float getResult() {
        return getNumberOne() - getNumberTwo();
    }
}

/**
 * @ClassName: OperationMul
 * @Description: 乘法操作实现类
 * @Author Wangnan
 * @Date 2016/8/17
 */
public class OperationMul extends Operation{

    @Override
    public float getResult() {
        return getNumberOne() * getNumberTwo();
    }
}

/**
 * @ClassName: OperationDiv
 * @Description: 除法操作实现类
 * @Author Wangnan
 * @Date 2016/8/17
 */
public class OperationDiv extends Operation{

    @Override
    public float getResult() {
        float result = 0f;
        try {
            result = getNumberOne() / getNumberTwo();
        } catch (Exception e){
            e.printStackTrace();
        }
        return result;
    }
}

3.接下来,我们的计算工厂要上场了。

/**
 * @ClassName: OperationFactory
 * @Description: 操作工厂
 * @Author Wangnan
 * @Date 2016/8/17
 */
public class OperationFactory {

    public static final String OPERATION_ADD = "add";  // 加法运算标识符
    public static final String OPERATION_SUBTRACT = "subtract"; // 减法运算标识符
    public static final String OPERATION_MULTIPLY = "multiply"; // 乘法运算标识符
    public static final String OPERATION_DIVIDE = "divide"; // 除法运算标识符

    public static Operation createOperation(String operation){
        Operation mOperation = null;
        switch (operation){
            case OPERATION_ADD:
                mOperation = new OperationAdd(); // 创建加操作运算对象
                break;
            case OPERATION_SUBTRACT:
                mOperation = new OperationSub(); // 创建减操作运算对象
                break;
            case OPERATION_MULTIPLY:
                mOperation = new OperationMul(); // 创建乘操作运算对象
                break;
            case OPERATION_DIVIDE:
                mOperation = new OperationDiv(); // 创建除操作运算对象
                break;
        }
        return mOperation;
    }
}

4.最后,我们的计算工厂已经写好了,那么该如何使用呢。

    Operation operation = OperationFactory.createOperation(OperationFactory.OPERATION_ADD); // 创建加法运算实例对象
    operation.setNumberOne(6F); // 给numberOne赋值
    operation.setNumberTwo(0.66F); // 给numberTwo赋值
    float result = operation.getResult(); // 获取计算结果 result = 6.66 

调用过程说明:

我们想对两数进行加法运算,需要计算工厂为我们创建一个加法实现类对象,然后操作该对象,进行加法运算并得到运算结果。

  1. 我们调用OperationFactory类的createOperation方法可以得到一个具体的计算操作实现类对象,但是具体是哪种操作是由你传入的参数决定的。我们想得到加法运算对象可以传入参数OperationFactory.OPERATION_ADD(或者是“add”),之后计算工厂就为我们创建了一个OperationAdd对象,并且给我们return了回来。

  2. 我们用一个声明为Operation类型的变量作为引用,引用刚刚return回来的OperationAdd对象,接下来我们对operation所引用对象的numberOne和numberTwo属性进行赋值。

  3. 最后,我们调用operation所引用对象的getResult()方法就可以将两数相加得到运算结果了。

总结:

现在我们再来理解一下理论:

简单工厂模式的实质是由一个工厂类根据传入的参数,动态决定应该创建哪一个产品类的实例。

如果我们向OperationFactory.createOperation()方法传入的参数是OperationFactory.OPERATION_ADD(或“add”)得到的是加法实现类(OperationAdd)对象。

如果我们向OperationFactory.createOperation()方法传入的参数是OperationFactory.OPERATION_SUBTRACT(或“subtract”)得到的是减法实现类(OperationSub)对象。

如果我们向OperationFactory.createOperation()方法传入的参数是OperationFactory.OPERATION_MULTIPLY(或“multiply”)得到的是乘法实现类(OperationMul)对象。

如果我们向OperationFactory.createOperation()方法传入的参数是OperationFactory.OPERATION_DIVIDE(或“divide”)得到的是除法实现类(OperationDiv)对象。

有没有一种恍然大悟的感觉,现在再回去理解就容易多了吧~

写的虽然有些啰嗦,但理解起来应该很容易了...O(∩_∩)O~
少侠,如果不是很理解,看来是功力不够,过段时间再来修炼一下吧!小编这位小司机已经是竭尽所能了~

推荐阅读更多精彩内容