大话设计模式之简单的工厂模式

通过面向对象的三大特征封装、继承和多态，简单的计算器代码实现

---

Operation运算类，这是一个父类，所有运算方法都继承此类。

public abstract class Operation {

    public BigDecimal numberA;

    public BigDecimal numberB;

    public BigDecimal getNumberA() {
        return numberA;
    }

    public void setNumberA(BigDecimal numberA) {
        this.numberA = numberA;
    }

    public BigDecimal getNumberB() {
        return numberB;
    }

    public void setNumberB(BigDecimal numberB) {
        this.numberB = numberB;
    }

    public abstract BigDecimal getResult();
}

这是一个抽象的类，里面有一个抽象的方法getResultI()，和两个Number属性。之所以使用抽象类，是因为继承抽象类，必须重写抽象类的抽象方法，通过子类实现计算功能。

---

OperationAdd 加法类，继承运算类

public class OperationAdd extends Operation {

    public BigDecimal getResult(){

        BigDecimal result = null;

        result = numberA.add(numberB);

        return result;
    }

}

OperationSubtract 减法类，继承运算类

public class OperationSubtract extends Operation {

    public BigDecimal getResult(){

        BigDecimal result = null;

        result = numberA.subtract(numberB);

        return result;
    }

}

OperationMultiply 乘法类，继承运算类

public class OperationMultiply extends Operation {

    public BigDecimal getResult(){

        BigDecimal result = null;

        result = numberA.multiply(numberB);

        return result;
    }

}

OperationDivide 除法类，继承运算泪

public class OperationDivide extends Operation {

    public BigDecimal getResult(){

        BigDecimal result = null;

        result = numberA.divide(numberB);

        return result;
    }

}

---

简单的工厂模式，就是用一个单独的类来做实例化对象的过程，这就是工厂，来，让我们看看工厂类怎么写。

OperationFactory 简单的运算工厂类

public class OperationFactory {

    public Operation createOperation(String optrate){

        Operation operation = null;

        switch (optrate) {
        case "+":

            operation = new OperationAdd();

            break;
        case "-":

            operation = new OperationSubtract();

            break;
        case "*":

            operation = new OperationMultiply();

            break;
        case "/":

            operation = new OperationDivide();

            break;

        default:
            break;
        }

        return operation;
    }

}

这样子，只需要输入运算符号，工厂就会实例化出合适的对象，通过多态，返回父类的方法实现了计算器的结果。

---

最后写一个Main方法实现计算功能

public class Main {

    public static void main(String[] args) {

        OperationFactory operationFactory = new OperationFactory();

        Operation operation = operationFactory.createOperation("*");

        operation.setNumberA(new BigDecimal("10"));
        operation.setNumberB(new BigDecimal("0.0058"));

        BigDecimal result = operation.getResult();

        System.out.println(result);
    }

}

如果以后需要更改加法运算，只需要改OperationAdd这个类就可以，需要添加各种复杂的运算，只需要添加相应的运算子类就可以，然后在修改运算类工厂，在switch中添加分支。

这样一个简单的工厂模式就实现了，这里面用到了面向对象的三大特征：封装一个抽象的运算父类，所以的算法类全部继承父类，通过算法工厂，多态的实例化出合适的对象。