回顧第一篇學習到的設計模式——【簡單工廠模式】，裡面講到了簡單工廠模式的本質是把業務進行拆分，可擴充套件性的功能單獨作為一個模組進行編寫，

最後再用一個總體排程的模組，確定具體要執行哪一種功能。

簡單工廠模式中，最重要的就是工廠類，裡面包含了所有涉及的方法：

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