设计模式从零开始——工厂方法模式

回顾第一篇学习到的设计模式——【简单工厂模式】，里面讲到了简单工厂模式的本质是把业务进行拆分，可扩展性的功能单独作为一个模块进行编写，

最后再用一个总体调度的模块，确定具体要执行哪一种功能。

简单工厂模式中，最重要的就是工厂类，里面包含了所有涉及的方法：

public class OperationFactory {

    public static Operator createOperator(String operator) {
        Operator oper = null;
        switch (operator) {
            case "+":
                oper = new OperatorAdd();
                break;
            case "-":
                oper = new OperatorSub();
                break;
            case "*":
                oper = new OperatorMul();
                break;
            case "/":
                oper = new OperatorDiv();
                break;
        }
        return oper;
    }
}

但是考虑一个问题，作为简单工厂模式去写一个计算器的功能，原有加减乘除的计算功能，但是要在这之上再添加求平方，开方等操作，

必然要在原有的工厂类中添加求平方、开方的方法，这就违反了设计模式中本承的【开放-封闭原则】，在原有的代码逻辑中进行修改，

而不是只是基于原有的逻辑添加需要的功能。

对于这部分的优化，就用到了【工厂方法模式】，这种设计模式是基于【简单工厂模式】的基础上，对于工厂类进行优化、解耦，

使工厂类本身只作为一个父类，把具体的实现方法作为一个个单独的子类，通过集成工厂类的方式，实现对于不同方法的调用。

【工厂方法模式】的好处在于遵循了【开放-封闭原则】，将工厂方法和实现类拆分开，提高了后续功能的扩展性。

以下是以计算器的代码为例，对于【工厂方法模式】的具体实现：

工厂类：

public interface IFactory {
    public Operation CreateOperation();
}

工厂方法：

public class AddFacory implements IFactory {
    @Override
    public Operation CreateOperation() {
        return new OperatorAdd();
    }
}

public class DivFactory implements IFactory {
    @Override
    public Operation CreateOperation() {
        return new OperatorDiv();
    }
}

public class MulFactory implements IFactory {
    @Override
    public Operation CreateOperation() {
        return new OperatorMul();
    }
}

public class SubFactory implements IFactory {
    @Override
    public Operation CreateOperation() {
        return new OperatorSub();
    }
}

操作类：

public class Operation {
    private double number_A = 0;
    private double number_B = 0;

    public double getNumber_A() {
        return number_A;
    }

    public void setNumber_A(double number_A) {
        this.number_A = number_A;
    }

    public double getNumber_B() {
        return number_B;
    }

    public void setNumber_B(double number_B) {
        this.number_B = number_B;
    }

    public double getResult() {
        double result = 0;
        return result;
    }
}

具体操作的实现类:

public class OperatorAdd extends Operation {
    @Override
    public double getResult() {
        double result = 0;
        result = getNumber_A() + getNumber_B();
        return result;
    }
}

public class OperatorDiv extends Operation {
    @Override
    public double getResult() {
        double result = 0;
        if (getNumber_B() == 0) {
            new Exception("除数不能为0");
        }
        result = getNumber_A() / getNumber_B();
        return result;
    }
}

public class OperatorMul extends Operation {
    @Override
    public double getResult() {
        double result = 0;
        result = getNumber_A() * getNumber_B();
        return result;
    }
}

public class OperatorSub extends Operation {
    @Override
    public double getResult() {
        double result = 0;
        result = getNumber_A() - getNumber_B();
        return result;
    }
}

客户端：

public class Caculator {
    public static void main(String[] args) {
        IFactory factory = new DivFactory();
        Operation operation = factory.CreateOperation();
        operation.setNumber_A(423132);
        operation.setNumber_B(34562);
        double result = operation.getResult();
        System.out.println(result);
    }
}

设计模式从零开始——工厂方法模式

猜你喜欢