大话设计模式读书笔记系列-1.简单工厂模式(静态工厂模式)

>>>大话设计模式读书笔记系列目录>>>

简单工厂模式(静态工厂模式)

简单设计模式不符合开放-封闭原则,如果新增一种运算需要涉及改动的类过多。

场景：采用简单工厂模式设计一款运算器可以自由添加运算规则

计算器运算抽象类

/**
 * 计算器运算抽象类
 */
public abstract class Operation {
    /**
     * 操作数A
     */
    private double numberA;
    /**
     * 操作数B
     */
    private double numberB;

    /**
     * 抽象方法
     * 获得操作结果
     *
     * @return
     */
    public abstract double getResult();

    /**
     * 获取 操作数A
     *
     * @return numberA 操作数A
     */
    public double getNumberA() {
        return this.numberA;
    }

    /**
     * 设置 操作数A
     *
     * @param numberA 操作数A
     */
    public void setNumberA(double numberA) {
        this.numberA = numberA;
    }

    /**
     * 获取 操作数B
     *
     * @return numberB 操作数B
     */
    public double getNumberB() {
        return this.numberB;
    }

    /**
     * 设置 操作数B
     *
     * @param numberB 操作数B
     */
    public void setNumberB(double numberB) {
        this.numberB = numberB;
    }

    @Override
    public String toString() {
        return "Operation{" +
                "numberA=" + numberA +
                ", numberB=" + numberB +
                '}';
    }
}

运算器子类

/**
 * 加法运算类
 */
public class OperationAdd extends Operation {

    @Override
    public double getResult() {
        return super.getNumberA() + super.getNumberB();
    }
}

/**
 * 减法运算类
 */
public class OperationSub extends Operation {
    @Override
    public double getResult() {
        return super.getNumberA() - super.getNumberB();
    }
}

/**
 * 乘法运算类
 */
public class OperationMul extends Operation {
    @Override
    public double getResult() {
        return super.getNumberA() * super.getNumberB();
    }
}

/**
 * 除法运算类
 */
public class OperationDiv extends Operation {
    @Override
    public double getResult() {
        return super.getNumberA() / super.getNumberB();
    }
}

运算静态工厂类

/**
 * 运算静态工厂类
 */
public class OperationFactory {
    /**
     * 创建运算工厂
     * @param operate 操作符(+ - * /)
     * @return 匹配运算类
     */
    public static  Operation createOperation(String operate)
    {
        Operation operation=null;
        switch (operate)
        {
            case "+":
                operation=new OperationAdd();//创建加法运算类
                break;
            case "-":
                operation=new OperationSub();//创建减法运算类
                break;
            case "*":
                operation=new OperationMul();//创建乘法运算类
                break;
            case "/":
                operation=new OperationDiv();//创建除法运算类
                break;
        }
        return operation;
    }
}

调用端

/**
 * 大话设计模式(java版)
 * 第一章:简单工厂模式(静态工厂模式)
 */
public class StaticFactoryMethodDemo {

    public static void main(String[] args) {
        Operation operation = null;
        double result = 0;
        operation = OperationFactory.createOperation("+");
        operation.setNumberA(1.1);
        operation.setNumberB(2.2);
        result = operation.getResult();
        System.out.println("加法结果".concat(String.valueOf(result)));

        operation = OperationFactory.createOperation("-");
        operation.setNumberA(3.3);
        operation.setNumberB(2.2);
        result = operation.getResult();
        System.out.println("减法结果".concat(String.valueOf(result)));

        operation = OperationFactory.createOperation("*");
        operation.setNumberA(3.3);
        operation.setNumberB(2.2);
        result = operation.getResult();
        System.out.println("乘法结果".concat(String.valueOf(result)));

        operation = OperationFactory.createOperation("/");
        operation.setNumberA(3.3);
        operation.setNumberB(2.2);
        result = operation.getResult();
        System.out.println("除法结果".concat(String.valueOf(result)));

    }
}

结果

加法结果3.3000000000000003
减法结果1.0999999999999996
乘法结果7.26
除法结果1.4999999999999998