简单工厂模式

这是第一发，我要立志记录一下我23种设计模式的学习记录，突然感觉如果写一个博客的话，那么我会记录的很清楚。

简单工厂原则的实质在于修改原来代码的时候不去修改其他方法的逻辑。

比如，我们写一个计算器，如果有一开始有一个加减乘除功能，现在需要一个开更号的功能，该怎么办？

如果按照没有学过设计模式的情况下，我们需要增加一个方法，在这个时候，因为这个方法是和原来的方法在一个类里面，所以我们修改的时候是可以修改原来的方法的。这样就有了不安全因素。所以说，我们应该让这些方法分离。

举个例子，计算器。计算两个数的加减乘除功能

这个是操作类

public class Operation {
    public double getNumberA() {
        return NumberA;
    }

    public void setNumberA(double numberA){
        NumberA = numberA;
    }

    public double getNumberB() {
        return NumberB;
    }

    public void setNumberB(double numberB){
        NumberB = numberB;
    }

    protected double NumberA;
    protected double NumberB;

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

然后再来四个子类继承他，就是四个方法。

public class OperationAdd extends Operation{
    public double GetResult(){
        double result = 0;
        result = this.getNumberA() + this.getNumberB();
        return result;
    }
}

public class OperationDiv extends Operation{
    public double GetResult(){
        double result = 0;
        result = this.getNumberA() / this.getNumberB();
        return result;
    }
}

public class OperationMul extends Operation{
    public double GetResult(){
        double result = 0;
        result = this.getNumberA() * this.getNumberB();
        return result;
    }
}

public class OperationSub extends Operation{
    public double GetResult(){
        double result = 0;
        result = this.getNumberA() - this.getNumberB();
        return result;
    }
}

以上是业务逻辑，然后就是界面

import java.util.Scanner;

public class User {
    public static void main(String[] args){
            double numberA , numberB;
            String sign;
            Scanner cin = new Scanner(System.in);
            System.out.println("请输入数字A:");
            numberA = cin.nextDouble();
            System.out.print("请输入选择运算的符号'+','-','*','/'");
            sign = cin.next();//如果是nextline的情况下，会读上面的空格，导致异常。
            System.out.println("请输入数字B：");
            numberB = cin.nextDouble();
            Operation oper;
            oper = OperationFactory.createOperate("*");
            oper.setNumberA(numberA);
            oper.setNumberB(numberB);
            double result = oper.GetResult();
            System.out.println(result);
            System.out.println("hello");
    }
}

有一个这个，就是那个工厂类，他根据不同的参数，来控制生成哪一个类

这是工厂类，就是根据传进参数的不同，来控制生成的子类。

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

接着看那个

Operation oper
            oper = OperationFactory.createOperate("*");

这个是代码的精髓，生成的是一个子类，但是以父类的身份出现。
这样写的方法，就是因为函数是一个返回值，之前不生成一个类，不知道返回的时候赋什么值。所以一定要先生成，但是由于不知道返回的是哪一个子类，所以，写父类，让他们继承父类，就可以用父类来，让子类以父类身份出现。

子类以父类身份出现，这就是简单工厂模式的牛逼的地方。