读大话设计模式(1)-----------简单工厂模式

书中以写一个简单计算器为例,先实现基本的加减乘除功能,并为其他计算方式提供便于扩展的工厂.

---

计算抽象类:

public abstract class Operation {

    private Double firstNumber;

    private Double secondNumber;

    public Double getFirstNumber() {
        return firstNumber;
    }

    public void setFirstNumber(Double firstNumber) {
        this.firstNumber = firstNumber;
    }

    public Double getSecondNumber() {
        return secondNumber;
    }

    public void setSecondNumber(Double secondNumber) {
        this.secondNumber = secondNumber;
    }
    public abstract Double getResoult();
}

---

计算类加减乘除实现:

public class OperationAdd extends Operation {
    @Override
    public Double getResoult() {
        return getFirstNumber() + getSecondNumber();
    }
}

public class OperationSubtract extends Operation {

    @Override
    public Double getResoult() {
        return getFirstNumber() - getSecondNumber();
    }
}

public class OperationMul extends Operation {
    @Override
    public Double getResoult() {
        return getFirstNumber() * getSecondNumber();
    }
}

public class OperationDiv extends Operation {
    @Override
    public Double getResoult() {
        if (getSecondNumber() == 0){
            throw new RuntimeException("除数不能为0.");
        }
        return getFirstNumber() / getSecondNumber();
    }
}

---

计算类工厂:

public class OperationFactory {
    public static Operation createOperate(String operate){
        Operation operation = null;
        switch (operate){
            case "+":
                operation = new OperationAdd();
                break;
            case "-":
                operation = new OperationSubtract();
                break;
            case "*":
                operation = new OperationMul();
                break;
            case "/":
                operation = new OperationDiv();
        }
        return operation;
    }
}

需要简单计算时可以调用工厂获得对应的计算类,如果有新的计算方式需要加入,写一个新类继承计算抽象类,并修改工厂类代码.

由此可见该模式的缺点,由于所有的创建逻辑都聚合在工厂类中,添加新的计算方式都要改动工厂类的代码.

使用场景

工厂类负责创建的对象比较少；

客户只知道传入工厂类的参数，对于如何创建对象（逻辑）不关心；

由于简单工厂很容易违反高内聚责任分配原则，因此一般只在很简单的情况下应用。