简单工厂模式

最新推荐文章于 2024-12-10 14:52:31 发布

原创最新推荐文章于 2024-12-10 14:52:31 发布 · 250 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#设计模式 #简单工厂模式

设计模式专栏收录该内容

1 篇文章

订阅专栏

本文通过逐步改进计算器实现，讲解简单工厂模式的应用，从原始代码的缺陷，到封装业务逻辑，最终实现可扩展的工厂设计。

前言：感觉是时候学点设计模式优化下代码了，这是本人学《大话设计模式》时所做的笔记

第一章简单工厂模式

1.1 计算器原始代码

这是最简陋的计算器代码，有如下几个问题，命名不规范、判断分支（每个条件都要判断四次，等于三次无用功）、如果除数时出现了异常会有问题

public class Calculator {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        String A = input.nextLine();
        String B = input.nextLine();
        String C = input.nextLine();
        String D= "";
        if(C.equals("+")){
          D=String.valueOf(Double.valueOf(A)+Double.valueOf(B));
        }
        if(C.equals("-")) {
            D = String.valueOf(Double.valueOf(A) - Double.valueOf(B));
        }
        if(C.equals("/")){
            D=String.valueOf(Double.valueOf(A)/Double.valueOf(B));
        }
        if(C.equals("*")){
            D=String.valueOf(Double.valueOf(A)*Double.valueOf(B));
        }
        System.out.println(D);
    }
}

1.2 简单改进版

这个解决了上面的问题，但是没有将界面何业务分开，不易维护何重复利用。

public class Calculator {
    public static void main(String[] args) {
        try {
            Scanner input = new Scanner(System.in);
            String strNumberA = input.nextLine();
            String strNumberB = input.nextLine();
            String strOperate = input.nextLine();
            String strResult = "";
            switch (strOperate) {
                case "+":
                    strResult = String.valueOf(Double.valueOf(strNumberA) + Double.valueOf(strNumberB));
                    break;
                case "-":
                    strResult = String.valueOf(Double.valueOf(strNumberA) - Double.valueOf(strNumberB));
                    break;
                case "*":
                    strResult = String.valueOf(Double.valueOf(strNumberA) * Double.valueOf(strNumberB));
                    break;
                case "/":
                    if (strNumberB.equals(0)) {
                        strResult = "除数不能是0";
                    } else {
                        strResult = String.valueOf(Double.valueOf(strNumberA) / Double.valueOf(strNumberB));
                    }
                    break;
            }
            System.out.println(strResult);
        } catch (Exception e){
            System.out.println(e.getMessage());
        }
    }
}

1.3 简单封装版

将业务封装了起来，可以将业务函数在其他地方复用了，但是还是有问题，如果要再加一种运算，你需要获取其它三种运算的方式（因为都在一个函数里面嘛），如果我们修改一个，还得让其它操作都来编译，这样不方便，所以这里我们要修改一个，不能影响其它。

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 "/":
                 result = numberA /numberB;
                break;
        }
        return result;
    }
}
public class Calculator {
    public static void main(String[] args) {
        try {
            Scanner input = new Scanner(System.in);
            String strNumberA = input.nextLine();
            String strNumberB = input.nextLine();
            String strOperate = input.nextLine();
            String strResult = "";
            strResult = String.valueOf(Operation.getResult(Double.valueOf(strNumberA),Double.valueOf(strNumberB),strOperate));
            System.out.println(strResult);
        } catch (Exception e){
            System.out.println(e.getMessage());
        }
    }
}

1.4 简单工厂模式


class Operation2{
    public double numberA;
    public double numberB;
    public double getResult() throws Exception {
        double result = 0;
        return result;
    }
}

class OperationAdd extends Operation2{
    @Override
    public double getResult(){
        double result = 0;
        result = numberA + numberB;
        return result;
    }
}

class OperationSub extends Operation2{
    @Override
    public double getResult(){
        double result = 0;
        result = numberA - numberB;
        return result;
    }
}

class OperationDiv extends Operation2{
    @Override
    public double getResult() throws Exception {
        double result = 0;
        if(numberB==0){
            throw new Exception("除数不能是0");
        }
        result = numberA + numberB;
        return result;
    }
}

class OperationMul extends Operation2{
    @Override
    public double getResult(){
        double result = 0;
        result = numberA * numberB;
        return result;
    }
}

class OperationFactory2{
    public static Operation2 createOperation(String operate){
        Operation2 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 class Calculator2 {
    public static void main(String[] args) {
        Operation2 oper;
        oper = OperationFactory2.createOperation("+");
        oper.numberA=1;
        oper.numberB=2;
        try {
            double result = oper.getResult();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}