简单工厂模式

用一个开发计算器的例子来讲解简单工厂模式，刚开始开发这个计算器的时候代码是这样的；

package out;
import java.util.Scanner;
import java.util.*;
public class SimpleFactoryPattern{

public static void main(String[]args){
        try{
            System.out.println("输入数字A:");
            Scanner sca = new Scanner(System.in);
            Integer inA = sca.nextInt();
            String strNumberA = Integer.toString(inA);
            // System.out.println(strNumberA);
            System.out.println("输入运算符:");
            // Scanner optscan = new Scanner(System.in);
            String optstr = sca.next();
            // Println(optstr);
            System.out.println("输入数字B:");
            // Scanner sc
            Integer intB = sca.nextInt();
            String strNumberB = Integer.toString(intB);
            String result = "";
            Integer re = null;
            switch(optstr){
                case "+":
                re = (Integer.parseInt(strNumberA)+Integer.parseInt(strNumberB));
                result = new String(re.toString());
                System.out.println("输出结果："+result);
                break;
                case "-":
                re = Integer.parseInt(strNumberA)-Integer.parseInt(strNumberB);
                result = new String(re.toString());
                System.out.println("输出结果："+result);
                break;
                case "*":
                re = Integer.parseInt(strNumberA)*Integer.parseInt(strNumberB);
                result = new String(re.toString());
                System.out.println("输出结果："+result);
                break;
                case "/":
                if(strNumberB != "0"){
                    re = Integer.parseInt(strNumberA)/Integer.parseInt(strNumberB);
                    result = new String(re.toString());
                }else{
                    result = "除数不能为0";
                }
                System.out.println("输出结果："+result);
                break;
            }
        }catch(Exception e){
        }
}

上面的代码可以运行，但是代码的鲁棒不好。没有很好的可维护性、可扩展性、可复用性，也就是灵活性不好。在写代码时需要考虑到代码的鲁棒性。上述的代码还可以这么改。
在编写一个类Operation.java用于运算，

public class Operation{
public static double GetResult(double numberA,double numberB,String operate){
        double result = 0d;
        switch(operate){
            case "+":
                result =  numberA+numberB;
                break;

            case "-":
                result = numberA-numberB;
                break;

            case "*":
                result = numberA*numberB;
                break;

            case "/":
                try{
                    if(numberB != 0d){
                        result = numberA/numberB;
                    }
                }catch(Exception e){
                    System.out.println("输入有误");
                }
                break;
        }
        return result;
    }

下面是调用运行：

public class SimpleFactoryPattern{
public static void main(String[]args){
        try{
            System.out.println("输入数字A:");
            Scanner sc = new Scanner(System.in);
            Double numberA = sc.nextDouble();

            System.out.println("输入运算符:");
            // Scanner opersc = sc.next();
            // String oper = opersc.toString();
            String oper = sc.next();
            // Println("运算符:"+oper);

            // Println("输入的数字："+numberA);
            System.out.println("输入数字B:");
            Double numberB = sc.nextDouble();
            Double result = Operation.GetResult(numberA,numberB,oper);
            Println("计算结果:"+result);
        }catch(Exception e){
        }
    }
}

代码没有问题，但是如果需要在添加一个计算功能，比如：计算平方或者开根，那是不是要在Operation类上做修改？如果这样做会给代码带来一个问题：紧耦合。比如在修改代码的过程中，不小心把运行良好的代码改了，这样就会给程序带来风险。
这个例子中可以把Operation类的变量和各个运算功能抽象出来，并且创建工厂类SimpleFactory和抽象运算类Operation的具体实现类。
抽象的运算类：

public abstract class Operation{
    private double numberA = 0;
    private double numberB = 0;

    public double getNumberA(){
        return numberA;
    }
    public void setNumberA(double numberA){
        this.numberA = numberA;
    }

    public double getNumberB(){
        return numberB;
    }
    public void setNumberB(double numberB){
        this.numberB = numberB;
    }
    public abstract double GetResult();
}

各个运算功能的实现类：

//public class Operations{}
class OperationAdd extends Operation{

    @Override
    public double GetResult() {
        double result = 0;
        result = getNumberA()+getNumberB();
        return result;
    }
}
class OperationSub extends Operation{
    @Override
    public double GetResult() {
        double result = 0;
        result = getNumberA()-getNumberB();
        return result;
    }
}
class OperationMul extends Operation{
    @Override
    public double GetResult() {
        double result = 0;
        result = getNumberA()*getNumberB();
        return result;
    }
}
class OperationDiv extends Operation{
    @Override
    public double GetResult() {
        double result = 0;
        if(getNumberB()==0){
            try{
            }catch(Exception e){
                System.out.println("除数不能为0");
            }
            
        }
        result = getNumberA()/getNumberB();
        return result;
    }
}

简单工厂类：

public class SimpleFactory {
    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){
      Operation oper;
      oper = SimpleFactory.createOperate("/");
      oper.setNumberA(5);
      oper.setNumberB(8);
      double result = oper.GetResult();
      System.out.println(result);
}