简单工厂模式

程序员文章站 2022-03-26 21:53:10

简单工厂模式标签（空格分隔）：设计模式什么是简单工厂模式简单工厂模式属于类的创建性模式，又叫作静态工厂方法模式。通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。简单工厂模式中包含的角色及其职责 1. 工厂角色：简单工厂模式的核心，它负责实现创建所有实例的内部逻辑， ......

通过一个计算器的例子来感受一下面向对象的三大特性

下面看一个计算器逻辑的实现：

public static void main(String[] args) {
        try{
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入第一个数字");
            double numA = scanner.nextDouble();
            System.out.println("请输入运算符（+-*/）");
            String operate = scanner.next();
            System.out.println("请输入第一个数字");
            double numB = scanner.nextDouble();
            String result = "";
            switch (operate){
                case "+":
                    result = String.valueOf(numA + numB);
                    break;
                case "-":
                    result = String.valueOf(numA - numB);
                    break;
                case "*":
                    result = String.valueOf(numA * numB);
                    break;
                case "/":
                    if(numB != 0){
                        result = String.valueOf(numA / numB);
                    }else {
                        System.out.println("您输入的参数有误，除数不能为0");
                    }
                    break;
            }
            System.out.println("结果为："+result);
        }catch(Exception e){
            System.out.println("您输入的参数有误");
        }
    }

乍一看没什么问题，该判断的逻辑也都判断了，也实现了一个简单计算器的基本功能，这样的编码方式是很直接的用计算机能够理解的逻辑来解决问题，这个逻辑本身没有错，但是这样的思维使得我们的程序只能满足当前的需求，程序不易维护、不易拓展、不易复用，这样的代码质量低、没有营养。

根据面向对象的三大特性来改造这段代码

封装

首先我们把计算机的业务逻辑封装起来，使得业务逻辑和界面逻辑分开
Operation类

public class Operation {
    public Double getResult(double numberA,double numberB,String operate){
        Double result = "";
            switch (operate){
                case "+":
                    result = numA + numB;
                    break;
                case "-":
                    result = numA - numB;
                    break;
                case "*":
                    result = numA * numB;
                    break;
                case "/":
                    if(numB != 0){
                        result = numA / numB;
                    }else {
                        System.out.println("您输入的参数有误，除数不能为0");
                    }
                    break;
            }
            return result;
    }
}

客户端类

public static void main(String[] args) {
        try{
            Operation operation = new Operation();
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入第一个数字");
            double numA = scanner.nextDouble();
            System.out.println("请输入运算符（+-*/）");
            String operate = scanner.next();
            System.out.println("请输入第一个数字");
            double numB = scanner.nextDouble();
            double result = operation.getResult(numA,numB);
            System.out.println("结果为："+result);
        }catch(Exception e){
            System.out.println("您输入的参数有误");
        }
    }

这样就完成了对业务对象的封装。

继承和多态

在完成了对业务对象的封装后，接下来这个小程序用上继承和多态。封装完成后的代码虽然把业务和界面分离开来了，但还是不能灵活的修改和扩展，比如新增加一个开方运算，就需要让加减乘除的代码都参与编译，如果不小心改动了其他地方的代码还可能影响原有业务的逻辑。所以现在的目标就是修改其中一个或者扩展功能时不影响原有的业务逻辑，这就要运用到继承和多态。
Operation类

@Data
public class Operation{
    private double numA = 0;
    private double numB = 0;
    public Double getResult(){
        double result = 0;
        return result;
    }
}

运算子类

public class OperateAdd extends Operation{
    @Override
    public Double getResult(String numberA,String numberB){
        return Double.parseDouble(numberA) + Double.parseDouble(numberB);
    }
}

public class OperateDiv extends Operation{
    @Override
    public Double getResult(String numberA,String numberB){
        double result = 0d;
        if(Integer.parseInt(numberB) == 0){
            System.out.println("除数不能为0!");
        }else{
            result +=  Double.parseDouble(numberA) / Double.parseDouble(numberB);
        }
        return result;
    }
}

public class OperateMul extends Operation{
    @Override
    public Double getResult(String numberA,String numberB){
        return Double.parseDouble(numberA) * Double.parseDouble(numberB);
    }
}

public class OperateSub extends Operation{
    @Override
    public Double getResult(String numberA,String numberB){
        return Double.parseDouble(numberA) - Double.parseDouble(numberB);
    }
}

现在进行完代码的处理后，后续的新增和修改运算方法都不会影响其他方法，代码的扩展性大大的加强了。现在的问题就是该如何去实例化对应的运算对象，由此引出简单的工厂模式。