简单工厂模式

今天看了一本关于设计模式的书随即写个笔记顺便总结下这本书是：《大话设计模式》

用代码实现一个简单的计算器

下面是最简单的实现计算机的代码

  1.  Scanner scanner = new Scanner(System.in);
  3.         System.out.println("第一个数字");
  4.         double n1 = scanner.nextDouble();
  5.         System.out.println("运算符");
  6.         String opt = scanner.next();
  7.         System.out.println("第二个数字");
  8.         double n2 = scanner.nextDouble();
  9.         String result = "";
  10.         switch (opt) {
  11.             case "+":
  12.                 result = String.valueOf((n1 + n2));
  13.                 break;
  14.             case "-":
  15.                 result = String.valueOf((n1 - n2));
  17.                 break;
  18.             case "*":
  19.                 result = String.valueOf((n1 * n2));
  21.                 break;
  22.             case "/":
  23.                 result = String.valueOf((n1 / n2));
  24.                 break;
  25.                 default:
  26.                     result = "输出的运算符错误";
  27.         }
  28.         System.out.println(result);

虽然我们可以实现加减乘除，但是呢 以后我们如果新加和改变功能的话会频繁的操作这个代码块，如果代码一直新增功能的话这个方法的业务逻辑将会变得愈来复杂所以我们使用面向对象的方式来简化这个代码块。

使用面向对象的方式简化计算器

  1. public class Operation {
  3.     public double add(double n1, double n2){
  4.         return  (n1 + n2);
  5.     }
  7.     public double min(double n1, double n2){
  8.         return  (n1 - n2);
  9.     }
  12.     public double mul(double n1, double n2){
  13.         return  (n1 * n2);
  14.     }
  17.     public double exc(double n1, double n2){
  18.         return  (n1 / n2);
  19.     }
  21. }

我们是用一个Operation类来把业务操作包装起来 如果我们新增和修改业务的话 我们只需要进行新增和修改对应的方法即可，但是我们作为面向对象来说我只用了 封装这个特性，当我们的业务量更大的话 这个类越发的不是那么简单的维护了，所以我们就使用更高级点的操作，简单工厂模式

使用简单工厂模式

抽象类给他们共同的行为

  1. public interface Operation {
  4.     /** 计算
  5.      * @return result
  6.      */
  7.     double getResult(double number01 , double number02);
  9. }

我们实现加法操作

  1. public class AddOperation implements Operation {
  3.     @Override
  4.     public double getResult(double number01, double number02) {
  5.         return number01 + number02;
  6.     }
  8. }

减法操作

  1. public class MinOperation implements Operation {
  2.     @Override
  3.     public double getResult(double number01, double number02) {
  4.         return number01 - number02;
  5.     }
  6. }

乘法操作

  1. public class MulOperation implements Operation {
  2.     @Override
  3.     public double getResult(double number01, double number02) {
  4.         return number01 * number02;
  5.     }
  6. }

除法操作

  1. public class ExcOperation implements Operation {
  2.     @Override
  3.     public double getResult(double number01, double number02) {
  4.         return number01 / number02;
  5.     }
  6. }

工厂类

  1. public class OperationFactory {
  3.     /**
  4.      *  根据参数得到具体的运算类
  5.      * @param command 指令
  6.      * @return 运算类
  7.      */
  8.     public static Operation getOperation(String command){
  10.         switch (command) {
  11.             case "+":
  12.                 return  new AddOperation();
  13.             case "-":
  14.                 return  new MinOperation();
  15.             case "*":
  16.                 return  new MulOperation();
  17.             case "/":
  18.                 return  new ExcOperation();
  19.             default:
  20.                 return (m , n) -> -1;
  21.         }
  23.     }
  26. }

执行操作

  1. public class Run {
  3.     public static void main(String[] args) {
  4.         Operation operation = OperationFactory.getOperation("+");
  5.         System.out.println(operation.getResult(1, 2));
  6.     }
  9. }

总结

我们在写代码的时候最初的时候就是只要能运行就是好了，当时当我们的业务庞大的时候我饭就感觉我们写的就是一堆屎山了，所以我们写代码的原则就是：可维护，可复用，易拓展 这三个特性加杂一起就是牛皮的代码。