【学习】设计模式--第一种：简单工厂模式

简单工厂模式--简单工厂模式是属于创建型模式，又叫做静态工厂方法模式。由一个工厂类创建实例对象。

一个简单的计算器设计：

父类：（所有的算法都继承该类，子类都复写getResult方法）

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

    public double getResult(){
        return 0;
    }

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

加法：

public class OperationAdd extends Operation {
    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() {
        if (super.getNumberB()==0){
            throw new RuntimeException("被除数不能为0");
        }
        return super.getNumberA()/super.getNumberB();
    }
}

工厂类：（通过传入的运算符判断生成对应的实体类）

public class OperationFactory {
    public static Operation createOperation(String operate){
        switch (operate){
            case "+":
                return new OperationAdd();
            case "-":
                return new OperationSub();
            case "*":
                return new OperationMul();
            case "/":
                return new OperationDiv();
            default:
                throw new RuntimeException("请输入运算符");
        }
    }
}

测试，调用：

public static void main(String[] args) {
        Operation oper = OperationFactory.createOperation("+");
        oper.setNumberA(12.85);
        oper.setNumberB(1);
        double result = oper.getResult();
        System.out.println(result);
    }

结构图：

总结：此模式结果比较简单，主要是通过工厂类判断创建对应的实体类，传入参数即可得到结果。

优点：降低代码耦合度，符合“低耦合”的特征。

缺点：如果增加某种算法时，需要增加该算法的实现类；并且要修改工厂类，添加判断分支，这样违反了“高内聚”原则。对以后的扩展性不友好。

使用情况：工厂类负责创建的类比较少的情况；