专栏首页盛开在夏天的太阳大话设计模式--第一章 简单工厂设计模式

大话设计模式--第一章 简单工厂设计模式

简单工厂设计模式

案例: 写一个计算器, 实现加减乘除.

分析:   1. 有两个数, num1 和 num2.

    2. 有一个操作符

    3. 有一个业务逻辑运算

第一步: 拿到这个业务, 我们直观的思考, 可以想象到这个业务非常简单:

package com.designModel.chapter1_simpleFactory.step1;

import java.io.IOException;
import java.util.Scanner;

/**
 * 计算器: 实现两个数的加, 减, 乘, 除
 * 
 * 第一步思路. 输入两个数, 一个运算符. 执行运算
 *
 */
public class Caculator {

    public static void main(String[] args) {
        try {
            String num1;
            String num2; 
            String operate;
            int result = 0;
            System.out.println("输入num1:");
            Scanner scan = new Scanner(System.in);
            num1 = scan.nextLine();
            System.out.println("输入num2:");
            scan = new Scanner(System.in);
            num2 = scan.nextLine();
            System.out.println("输入运算符:");
            scan = new Scanner(System.in);
            operate = scan.nextLine();
            
            int n1 = Integer.parseInt(num1);
            int n2 = Integer.parseInt(num2);
            
            switch(operate){
                case "+":
                    result = n1 + n2;
                    break;
                case "-":
                    result = n1 - n2;
                    break;
                case "*":
                    result = n1 * n2;
                    break;
                case "/":
                    result = n1 / n2;
                    break;
            }
            
            System.out.println("运算结果:" + result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 这样操作的问题: 前端输入和后端逻辑运算完全混合在一起. 维护起来及其不方便
     * 那么如果优化, 第一步就是讲前端输入和业务逻辑分开处理
     */

}

分析:

这样操作的问题: 
    前端输入和后端逻辑运算完全混合在一起. 维护起来非常不方便

这里完全没有使用到面向对象的特征. 下面回顾面向对象的特征

1. 可维护性:  程序出现问题了, 方便维护修改, 且不会影响到其他正常的业务逻辑
2. 可复用性: 一段代码可以在多处被使用
3. 可扩展性: 有新的需求, 在不改变原来逻辑的基础上方便的增减
4. 灵活性: 无论是放在哪里, 稍微改变就可实现新的业务逻辑.

从这四个方面考虑. 上面这段代码, 维护性差, 改一个地方很可能或误改正确的地方; 复用性, 除了计算器, 其他地方基本不可用. 扩展性也不好, 添加一个开方, 可能误改加减乘除. 灵活性, 就没有.

那么. 如何使用面向对象的方式来修改呢?

第二步. 将业务逻辑和前端页面相分离

package com.designModel.chapter1_simpleFactory.step2;

import java.io.IOException;
import java.util.Scanner;

/**
 * 计算器: 实现两个数的加, 减, 乘, 除
 * 
 * 第一步思路. 输入两个数, 一个运算符. 执行运算
 * --------------------------------------
 * 再上一个案例的基础上, 将前端和后端逻辑分开处理
 * 
 */
public class Caculator {

    public int caculate(int n1, int n2, String operate){
        int result = 0;
        switch(operate){
            case "+":
                result = n1 + n2;
                break;
            case "-":
                result = n1 - n2;
                break;
            case "*":
                result = n1 * n2;
                break;
            case "/":
                result = n1 / n2;
                break;
        }
        return result;
    }
    
    public static void main(String[] args) {
     //前端输入
        try {
            String num1;
            String num2; 
            String operate;
            int result = 0;
            System.out.println("输入num1:");
            Scanner scan = new Scanner(System.in);
            num1 = scan.nextLine();
            System.out.println("输入num2:");
            scan = new Scanner(System.in);
            num2 = scan.nextLine();
            System.out.println("输入运算符:");
            scan = new Scanner(System.in);
            operate = scan.nextLine();
            
            int n1 = Integer.parseInt(num1);
            int n2 = Integer.parseInt(num2);
            
            Caculator c = new Caculator();
            result = c.caculate(n1, n2, operate);
            
            System.out.println("运算结果:" + result);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
    
    
    /**
     * 现在计算逻辑和前端数据处理的逻辑分开了. 可是依然有问题, 问题在哪里呢? 计算业务逻辑将耦合性太强
     * 比如: 我现在要添加一个算法,开平方根. 这时候, 需要在也逻辑处进行修改, 添加一个switch分支. 这是后, 如果业务逻辑大的话, 
     * 很可能会误操作更改了之前已经写好的的业务逻辑.
     * 
     * 例如: 我们的薪资系统
     * 原来只有技术人员(月薪), 销售人员(底薪+提成), 经理(年薪+股份)三种运算方法, 现在要增加兼职工作人员(时薪)的算法.
     * 
     * 按照我们上面的代码逻辑, 公司必须把包含原三种算法的运算累给你, 让你修改. 这是, 如果你有点私心, 小算盘一打, 除了增加时薪外, 
     * 还修改了技术人员的薪资
     *         salary = salary * 1.1;
     * 那就意味着你的月薪会增加10%. 本来是让你加一个功能的, 结果却修改了另一个功能. 这个风险太大了. 
     * 
     * 所以: 我们要改进这种算法. 分离加减乘除, 让其中一个运算修改, 不会影响到另外几个.
     * 这就用到了面向对象的三大特性: 封装, 继承 和 多态.
     * 
     */

}

正如上面代码的总结:

   /**
     * 现在计算逻辑和前端数据处理的逻辑分开了. 可是依然有问题, 问题在哪里呢? 计算业务逻辑将耦合性太强
   *
     * 比如: 我现在要添加一个算法,开平方根. 这时候, 需要在业务逻辑处进行修改, 添加一个switch分支. 这时, 如果业务逻辑大的话, 
     * 很可能会误操作更改了之前已经写好的的业务逻辑.
     * 
     * 例如: 我们的薪资系统
     * 原来只有技术人员(月薪), 销售人员(底薪+提成), 经理(年薪+股份)三种运算方法, 现在要增加兼职工作人员(时薪)的算法.
     * 
     * 按照我们上面的代码逻辑, 公司必须把包含原三种算法的运算类给你, 让你修改. 这时, 如果你有点私心, 小算盘一打, 除了增加时薪外, 
     * 还修改了技术人员的薪资
     *         salary = salary * 1.1;
     * 那就意味着你的月薪会增加10%. 本来是让你加一个功能的, 结果却修改了另一个功能. 这个风险太大了. 
     * 
     * 所以: 我们要改进这种算法. 分离加减乘除, 让其中一个运算修改, 不会影响到另外几个.
   *
     * 这就用到了面向对象的三大特性: 封装, 继承 和 多态.
     * 
     */

第三步:将输入参数封装成对象, 将加减乘除的业务逻辑单独出来一个类,

package com.designModel.chapter1_simpleFactory.step3;

public class Operation {

    private double num1;
    private double num2;
    
    public double getResult(){
        double result = 0;
        return result;
    }
    
    public double getNum1() {
        return num1;
    }
    
    public void setNum1(double num1) {
        this.num1 = num1;
    }
    
    public double getNum2() {
        return num2;
    }
    
    public void setNum2(double num2) {
        this.num2 = num2;
    } 
}
package com.designModel.chapter1_simpleFactory.step3.biz;

import com.designModel.chapter1_simpleFactory.step3.Operation;

public class OperationAdd extends Operation{
    @Override
    public double getResult() {
        return super.getNum1() + super.getNum2();
    }
}
package com.designModel.chapter1_simpleFactory.step3.biz;

import com.designModel.chapter1_simpleFactory.step3.Operation;

public class OperationSub extends Operation{
    @Override
    public double getResult() {
        return super.getNum1() - super.getNum2();
    }
}
package com.designModel.chapter1_simpleFactory.step3.biz;

import com.designModel.chapter1_simpleFactory.step3.Operation;

public class OperationMul extends Operation{
    @Override
    public double getResult() {
        return super.getNum1() * super.getNum2();
    }
}
package com.designModel.chapter1_simpleFactory.step3.biz;

import com.designModel.chapter1_simpleFactory.step3.Operation;

public class OperationDiv extends Operation{
    @Override
    public double getResult() {
        if(super.getNum2() == 0){
            try {
                throw new Exception("除数不能为零");
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return super.getNum1() / super.getNum2();
    }
}

这时候, 我在增加一个开平方根的算法, 就不会影响到其他四个类的算法了? 那么, 如何让计算器知道我要用那个算法呢?

现在的问题就是如何实例化对象了. ---- 简单工厂设计模式.

package com.designModel.chapter1_simpleFactory.step3;

import com.designModel.chapter1_simpleFactory.step3.biz.OperationAdd;
import com.designModel.chapter1_simpleFactory.step3.biz.OperationDiv;
import com.designModel.chapter1_simpleFactory.step3.biz.OperationMul;
import com.designModel.chapter1_simpleFactory.step3.biz.OperationSub;

public class OperationFactory {
    
    public static Operation createOperate(String operate) {
        Operation ope = null;
        switch(operate){
            case "+":
                ope = new OperationAdd();
                break;
            case "-":
                ope = new OperationSub();
                break;
            case "*":
                ope = new OperationMul();
                break;
            case "/":
                ope = new OperationDiv();
                break;
        }
        return ope;
    }    
}

在使用的时候, 你只需像下面这样操作就可以了.

public static void main(String[] args) {
    Operation ope = new Operation();
    ope = OperationFactory.createOperate("+");
    
    ope.setNum1(10);
    ope.setNum2(20);
    
    System.out.println(ope.getResult());
    
}

使用了工厂设计模式以后, 当你想要增加一个开平方根的算法时, 要怎么做呢?

1. 增加一个开平方根的类继承自Operation.

2. 在工厂中增加一个case分支.

搞定!

一个小小的计算器, 也可以使用算法. 那么我们在使用其他的方式的时候, 更要考虑算法了?

---------------------------------------------------------------------

总结:

在实际项目中,简单工厂模式是我们使用的最多的设计模式之一,简单工厂模式在应对需求变更的过程中也起到了很大的作用。

使用情景: 再不确定会有多少个处理操作时应该考虑使用简单工厂模式,如针对同样的接收到的数据,处理的逻辑可能会不同,可能以后还会增加新的操作。

案例:   例如如果实现计算器的功能时,对于同样的输入数据,可能执行加、减、乘、除,甚至其他的功能。因此可以抽象出一个操作的抽象类或是接口,提供一个统一的处理方法(此处为process),然后每种操作创建出一个子类出来。而判断具体使用哪个具体的实现类是在工厂类中进行判断的(将存放操作的变量传递给工厂的生产方法)。工厂类始终返回的是这个抽象类,这样如果对原有功能进行更改或是新添加新的功能,也不会对原来的其他类做修改,只编译修改的那个类或是新的类就可以了。 这样就做到了把耦合降到最低,同时也便于维护。

注意:如果客户提出要再添加一个功能来处理这些数据,实现起来就灰常方便了

-----------------------------------------------------------------------

UML类图

这个计算器类的UML图如下:

下面来学习一下UML类图的画法

总结:

空心三角形+实现-->继承 空心三角形+虚线-->实现接口 实线+箭头-->关联关系 徐建+箭头-->依赖关系 实心菱形+实线+箭头-->组合关系 空心菱形+实线+箭头-->聚合关系

-----------------------------------------------------------------------

简单工厂设计模式, 在项目中, 可以使用的场景

1. 支付: 支付有支付宝支付, 微信支付, 还有银联支付. 以后还可能有新的支付方式. 这时候就可以使用简单工厂设计模式.

处理方式:

斜体表示抽象类: 例如Pay类

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 3.2spring源码系列----循环依赖源码分析

    首先,我们在3.1 spring5源码系列--循环依赖 之 手写代码模拟spring循环依赖 中手写了循环依赖的实现. 这个实现就是模拟的spring的循环依赖...

    用户7798898
  • 大话设计模式--第七章 代理模式

    1. 卓贾易喜欢娇娇, 但是, 娇娇并不认识卓贾易, 那么他给娇娇送花, 送巧克力,送洋娃娃

    用户7798898
  • 第十一章 http标准库和其他标准库

    四. 第四个讲的是pprof, 我之前在测试的时候已经详细研究过pprof用来监控web服务的性能, 这里就不在描述了,

    用户7798898
  • Flutter lesson 9: Flutter的网络(HTTP)请求

    Flutter中网络请求有两种,一个是使用Flutter自带的网络请求,另一种则是使用第三方HTTP请求插件dio

    踏浪
  • Aop介绍及几种实现方式

    Aop介绍 我们先看一下wiki百科的介绍 Traditional software development focuses on de...

    少羽大怪兽
  • 组合模式浅析

    组合模式是指将对象组合成树形结构以表示“部分-整体”的层次结构,组合模式使得用户对单个对象和组合对象的使用具有一致性。

    孟君
  • dump_stack 分析使用

    dump_stack是用来回溯内核运行的信息的,打印内核信息堆栈段; dump_stack原型: void dump_stack(void); 1、使用这个功能...

    233333
  • ASP.NET Core分布式项目实战(业务介绍,架构设计,oAuth2,IdentityServer4)--学习笔记

    https://www.ruanyifeng.com/blog/2014/05/oauth_2_0.html

    郑子铭
  • 如何让搜索引擎抓取AJAX内容?

    越来越多的网站,开始采用"单页面结构"(Single-page application)。 整个网站只有一张网页,采用Ajax技术,根据用户的输入,加载不同的内...

    ruanyf
  • Java设计模式之模板方法模式

    假设我们现在要造一批悍马汽车,悍马汽车有两个系列H1和H2,首先不考虑任何设计模式,看看设计的类图:

    CoderJed

扫码关注云+社区

领取腾讯云代金券