首页 友情链接

设计模式-简单工厂模式

时间 2019/3/24 11:27:23 加载中...

场景

老大：

做个简单的加减乘除功能

我：

好的，那我先用java做个控制台版本的。

老大：

可以

于是，我开始动工，使用 eclipse 新建了一个简单的控制台项目，写下如下的代码：

  1. import java.util.Scanner;
  3. public class SimplePattern {
  5.     public static void main(String[] args) {
  7.         Scanner scanner = new Scanner(System.in);
  9.         System.out.println("目前支持 加、减、乘、除 四种运算 \r加法请输入1，减法请输入2，乘法请输入3，除法请输入4。");
  10.         System.out.println("请选择算法:");
  12.         String operateNum = scanner.nextLine();
  13.         //对 operateNum 的验证略（非空验证，值为1，2，3，4其中一个值的验证）
  15.         System.out.println("请输入其中一个数字：");
  17.         String oneNumber = scanner.nextLine();
  18.         System.out.println("输入的数字是：" + oneNumber);
  19.         System.out.println("请输入另外一个数字：");
  21.         String anotherNumber = scanner.nextLine();
  22.         System.out.println("输入的另外一个数字是：" + anotherNumber);
  24.         scanner.close();
  25.         //todo：oneNumber 和 anotherNumber 需要验证是否是数字，这里省略        
  27.         Double one = Double.parseDouble(oneNumber);
  28.         Double another = Double.parseDouble(anotherNumber);
  30.         Double result = 0d;
  32.         if(operateNum.equals("1")) {
  33.             result = one + another;
  34.         }else if(operateNum.equals("2")) {
  35.             result = one - another;
  36.         }else if(operateNum.equals("3")) {
  37.             result = one * another;
  38.         }else if(operateNum.equals("4")) {
  40.             if(another.equals(0d)) {
  41.                 System.out.println("除数不能为0");
  42.                 return;
  43.             }
  45.             result = one / another;
  46.         }
  48.         System.out.println("计算的结果是：" + result);
  49.     }
  50. }

搞定了，心想：

总算写完了，老大还没找我，反正写完了，休息一会，聊聊天，逛逛网页。

几分钟过去了…

不行，我要表现的积极些，不能老大找我，我才汇报情况，我得主动出击，去告诉一下我这的情况。

我向老大的工位走去…

我：

老大，东西弄完了，你看下行不行。

我向老大演示了一下，老大说道：

老大：

功能是没问题，你把业务逻辑提取一下，就是封装到一个类中，接下来的项目我们要用到。要做到复用。

我：

好的。

我看着代码，想了想：

目前是控制台版本的，如果集成到项目中，可能是 Web 版本，或其他版本的，和现在的区别就是获取用户输入的信息的方式不同而已。计算逻辑还是一样的，把一样的逻辑提取出来就可以了。

想明白了，动手。

新建了一个计算器类：

  1. package SimplePattern02;
  3. public class Calculator {
  4.     public Double getResult(String oneNumber,String anotherNumber,String operateNum) throws Exception {
  6.         //对 operateNum 的验证略（非空验证，值为1，2，3，4其中一个值的验证）
  7.         //todo：oneNumber 和 anotherNumber 需要验证是否是数字，这里省略
  9.         Double one = Double.parseDouble(oneNumber);
  10.         Double another = Double.parseDouble(anotherNumber);
  12.         Double result = 0d;
  14.         if(operateNum.equals("1")) {
  15.             result = one + another;
  16.         }else if(operateNum.equals("2")) {
  17.             result = one - another;
  18.         }else if(operateNum.equals("3")) {
  19.             result = one * another;
  20.         }else if(operateNum.equals("4")) {
  22.             if(another.equals(0d)) {
  23.                 throw new Exception("除数不能为0");
  24.             }
  26.             result = one / another;
  27.         }
  29.         return result;
  30.     }
  31. }

这样控制台的部分代码就简化了很多：

  1. package SimplePattern02;
  3. import java.util.Scanner;
  5. public class Program {
  7.     public static void main(String[] args) {
  8.         Scanner scanner = new Scanner(System.in);
  10.         System.out.println("目前支持 加、减、乘、除 四种运算 \r加法请输入1，减法请输入2，乘法请输入3，除法请输入4。");
  11.         System.out.println("请选择算法:");
  13.         String operateNum = scanner.nextLine();
  14.         System.out.println("请输入其中一个数字：");
  16.         String oneNumber = scanner.nextLine();
  17.         System.out.println("输入的数字是：" + oneNumber);
  18.         System.out.println("请输入另外一个数字：");
  20.         String anotherNumber = scanner.nextLine();
  21.         System.out.println("输入的另外一个数字是：" + anotherNumber);
  23.         scanner.close();
  25.         Calculator cal = new Calculator();
  26.         Double result = 0d;
  27.         try {
  28.             result = cal.getResult(oneNumber, anotherNumber, operateNum);
  29.         } catch (Exception e) {
  30.             System.out.println(e.getMessage());
  31.             return;
  32.         }
  34.         System.out.println("计算结果为：" + result);
  36.     }
  38. }

搞定后，我又去找老大汇报。

我：

老大，我搞完了，你再看下。

老大：

好，我看下。嗯…. 目前而言，差不多了。
你这个计算器类下的业务逻辑还不算复杂，
你这里用到了4个if判断，现在每个判断里面也就1行代码。所以，目前就可以了。
后面如果变复杂的话，你就还需要优化了。比如说，如果你每个if下面都10几行代码，那这个计算器类就显得过于复杂了。这时候，你就可以把每个if的业务逻辑抽离出来了。

我想了想。先提前抽离一下，当需要抽离的时候，自己好轻车熟路。

于是，我将4个if抽离成了4个业务逻辑，加法运算，减法运算，乘法运算，除法运算。
分别为每个运算定义了一个类。这些类都实现一个名为“运算”的接口。

接口

  1. package SimplePattern03;
  3. public interface IOperation {
  4.     Double getResult() throws Exception;
  5. }

加法运算

  1. package SimplePattern03;
  3. public class OperationAdd implements IOperation {
  5.     private Double one;
  6.     private Double another;
  8.     public Double getOne() {
  9.         return one;
  10.     }
  12.     public void setOne(Double one) {
  13.         this.one = one;
  14.     }
  16.     public Double getAnother() {
  17.         return another;
  18.     }
  20.     public void setAnother(Double another) {
  21.         this.another = another;
  22.     }
  24.     @Override
  25.     public Double getResult() {
  26.         return one + another;
  27.     }
  29. }

减法运算

  1. package SimplePattern03;
  3. public class OperationSub implements IOperation {
  5.     private Double one;
  6.     private Double another;
  8.     public Double getOne() {
  9.         return one;
  10.     }
  12.     public void setOne(Double one) {
  13.         this.one = one;
  14.     }
  16.     public Double getAnother() {
  17.         return another;
  18.     }
  20.     public void setAnother(Double another) {
  21.         this.another = another;
  22.     }
  24.     @Override
  25.     public Double getResult() {
  26.         return one - another;
  27.     }
  29. }

乘法运算

  1. package SimplePattern03;
  3. public class OperationMul implements IOperation {
  5.     private Double one;
  6.     private Double another;
  8.     public Double getOne() {
  9.         return one;
  10.     }
  12.     public void setOne(Double one) {
  13.         this.one = one;
  14.     }
  16.     public Double getAnother() {
  17.         return another;
  18.     }
  20.     public void setAnother(Double another) {
  21.         this.another = another;
  22.     }
  24.     @Override
  25.     public Double getResult() {
  26.         return one * another;
  27.     }
  29. }

除法运算

  1. package SimplePattern03;
  3. public class OperationDiv implements IOperation {
  5.     private Double one;
  6.     private Double another;
  8.     public Double getOne() {
  9.         return one;
  10.     }
  12.     public void setOne(Double one) {
  13.         this.one = one;
  14.     }
  16.     public Double getAnother() {
  17.         return another;
  18.     }
  20.     public void setAnother(Double another) {
  21.         this.another = another;
  22.     }
  24.     @Override
  25.     public Double getResult() throws Exception {
  26.         if(another.equals(0d)) {
  27.             throw new Exception("除数不能为0");
  28.         }
  29.         return one / another;
  30.     }
  32. }

工厂模式

四个逻辑出来了，这样计算器类中只是根据不同的情况来创建不同的对象实例即可。我把这个根据不同情况创建实例的任务也分离出去吧

  1. package SimplePattern03;
  3. public class OperationFactory {
  4.     public static IOperation getOperation(Double one,Double another, String operateNum) {
  6.         IOperation operation = null;
  7.         if(operateNum.equals("1")) {
  8.             OperationAdd oper = new OperationAdd();
  9.             oper.setOne(one);
  10.             oper.setAnother(another);
  11.             operation = oper;
  12.         }else if(operateNum.equals("2")) {
  13.             OperationSub oper = new OperationSub();
  14.             oper.setOne(one);
  15.             oper.setAnother(another);
  16.             operation = oper;
  17.         }else if(operateNum.equals("3")) {
  18.             OperationMul oper = new OperationMul();
  19.             oper.setOne(one);
  20.             oper.setAnother(another);
  21.             operation = oper;
  22.         }else if(operateNum.equals("4")) {
  23.             OperationDiv oper = new OperationDiv();
  24.             oper.setOne(one);
  25.             oper.setAnother(another);
  26.             operation = oper;
  27.         }
  28.         return operation;
  29.     }
  30. }

这里的 OperationFactory 就是简单工厂模式。

这样，计算器类就变成这样了。

  1. package SimplePattern03;
  3. public class Calculator {
  4.     public Double getResult(String oneNumber,String anotherNumber,String operateNum) throws Exception {
  6.         //对 operateNum 的验证略（非空验证，值为1，2，3，4其中一个值的验证）
  7.         //todo：oneNumber 和 anotherNumber 需要验证是否是数字，这里省略
  9.         Double one = Double.parseDouble(oneNumber);
  10.         Double another = Double.parseDouble(anotherNumber);
  12.         Double result = 0d;
  13.         IOperation oper = OperationFactory.getOperation(one, another, operateNum);
  14.         result = oper.getResult();
  16.         return result;
  17.     }
  18. }

这样，以后哪个运算逻辑要修改，只改对应的类即可。增加了运算逻辑，也就再新增一个运算类即可。维护起来简单多了。

扫码分享
版权说明
作者：SQBER
文章来源：http://www.sqber.com/articles/simple-factory-pattern.html
本文版权归作者所有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。
sqber 2017-2021 冀ICP备17029815 站点地图