工厂模式

之前写的那个简单工厂模式，虽然解决了修改时避免修改其他业务逻辑的问题，并且将对象的创建工作和客户端进行了剥离。，但是违反了开放封闭原则

---

这个有这样的一个问题，就是每次增加逻辑的时候，就需要修改工厂类，就很挫，最好是能让他拓展一下。符合开放封闭原则。我们可以让工厂类成为一个接口，然后具体生成什么子类，在客户端中实现。

工厂类

public interface IFactory {
    Operation CreateOperation();
}

接下来是操作类

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

这个是一些具体的工厂方法。将客户端与对象创建剥离。

public class AddFactory implements IFactory{
    public Operation CreateOperation() {
        return new OperationAdd();
    }

}


public class DivFactory implements IFactory{
    public Operation CreateOperation(){
        return new OperationDiv();
    }
}


public class MulFactory implements IFactory{
    public Operation CreateOperation(){
        return new OperationMul();
    }
}


public class SubFactory implements IFactory{
    public Operation CreateOperation(){
        return new OperationSub();
    }
}

接下来是客户端代码

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();
            System.out.println("请输入数字B：");
            numberB = cin.nextDouble();
            IFactory operFactory = null ;
            switch(sign){
            case "+":
                operFactory = new AddFactory();
                break;
            case "-":
                operFactory = new SubFactory();
                break;
            case "*":
                operFactory = new MulFactory();
                break;
            case "/":
                operFactory = new DivFactory();
                break;
            }
            Operation oper = operFactory.CreateOperation();
            oper.setNumberA(numberA);
            oper.setNumberB(numberB);
            double result = oper.GetResult();
            System.out.println(result);

        //  System.out.println(numberA + "--" + numberB);
    }
}

小结一下

以前，我以为简单工厂方法就是为了修改业务逻辑的时候避免修改其他方法，今儿看了别人的才知道，还有一个主要的原因是剥离了客户端与对象创建工作，客户端不需要知道对象是怎么创建的。
昨天我看工厂方法的时候，感觉，具体工厂好像没有用，直接换成构造函数好像也没什么。但是这样客户端就必须参与对象的创建工作我们现在使用的无参构造函数，没有什么区别，但是当构造函数有参数的时候，就能体现这个模式的好处了。