设计模式-简单工厂模式

 

在了解简单工厂模式之前，我们可以先了解一下强弱耦合这么一个概念，然后在引入为什么使用简单工厂模式。

直接上代码，这可能是大部分人直接想到的思路。

        System.out.println("请输入数字A:");
        Scanner scanA = new Scanner(System.in);
        String strNumberA = scanA.nextLine();

        System.out.println("请选择运算符号（+ - * /）:");
        Scanner scanOper = new Scanner(System.in);
        String strOperate = scanOper.nextLine();

        System.out.println("请输入数字B:");
        Scanner scanB = new Scanner(System.in);
        String strNumberB = scanB.nextLine();

        String strResult = "";
        switch (strOperate){
            case "+":
                strOperate = String.valueOf(Double.valueOf(strNumberA)+Double.valueOf(strNumberB));
                break;
            case "-":
                strOperate = String.valueOf(Double.valueOf(strNumberA)-Double.valueOf(strNumberB));
                break;
            case "*":
                strOperate = String.valueOf(Double.valueOf(strNumberA)*Double.valueOf(strNumberB));
                break;
            case "/":
                if (strNumberB != "0"){
                    strOperate = String.valueOf(Double.valueOf(strNumberA)/Double.valueOf(strNumberB));
                }else {
                    strResult = "除数不能为0";
                }
                break;
        }
        System.out.println("结果为："+strResult);
    }

　　但是如果是这种写法，你想要加一个功能，比如说开平方，是不是又要加一个case。代码上这么写确实没有问题，但是存在一个隐患，1.这个耦合度太大了，代码全部写在一块，不小心容易改了其他的代码。2.其次是我只想加个开平方的功能，我却让其他的功能暴露在你眼前，容易造成恶意改代码。

　　造成上述的问题，就是因为耦合度太大了，所以我们要重新设计一下，降低耦合度。

public class Operation {
    public double _numberA = 0;
    public double _numberB = 0;
    public double getResult() throws Exception {
        double result = 0;
        return result;
    }



    class OperationAdd extends Operation{
        public double getResult(){
            double result = 0;
            result = _numberA + _numberB;
            return result;
        }
    }
    class OperationSub extends Operation{
        public double getResult(){
            double result = 0;
            result = _numberA - _numberB;
            return result;
        }
    }
    class OperationMul extends Operation{
        public double getResult(){
            double result = 0;
            result = _numberA * _numberB;
            return result;
        }
    }
    class OperationDiv extends Operation{
        public double getResult() throws Exception {
            double result = 0;
            if(_numberB==0)
                throw new Exception("除数不能为0");
            result = _numberA / _numberB;
            return result;
        }
    }

通过这种方式，大大的降低了耦合度。但是也引出一个新的问题，应用怎么知道我们到底想用什么算法，子类有那么多个。因此根据这个问题，引出了简单工厂模式。

简单工厂模式

　　简单工厂模式又称为静态工厂方法模型，它属于类创建型模式。在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

　　

public class OperationFactory {
    public static Operation createOperate(String operate){
        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;
    }

    public static void main(String[] args) throws Exception {
        Operation oper;
        oper = OperationFactory.createOperate("+");
        oper._numberA=1;
        oper._numberB=2;
        double result = oper.getResult();
    }
}

这种实现类的方式是不是特别的灵活，子类的实现方式通过一个参数去选择。

 

　结论：通过这个例子可以看出来，如果在增加一个子类，我们对代码的修改只有2处，1个就是工厂类在增加新的产品的实现，1个就是增加一个类继承公共父类来描述产品。