设计模式-行为型

kksilu

已于 2022-08-03 23:12:30 修改

阅读量534

点赞数

分类专栏：设计模式文章标签：设计模式策略模式 java

于 2022-03-17 16:36:09 首次发布

本文链接：https://blog.csdn.net/qq_40337086/article/details/120833349

版权

设计模式专栏收录该内容

7 篇文章 0 订阅

订阅专栏

文章目录

观察者模式
迭代器模式
复用&扩展
状态模式
备忘录模式
中介模式
命令模式
解释器模式

我们常把 23 种经典的设计模式分为三类：创建型、结构型、行为型。我们知道，设计模式要干的事情就是解耦

创建型模式是将创建和使用代码解耦
结构型模式是将不同功能代码解耦
行为型模式是将不同的行为代码解耦

行为型设计模式主要有以下几种:

观察者模式

观察者模式也被称为发布订阅模式
订阅模式我们就很好理解了，就是在对象之间定义一个一对多的依赖，当一个对象状态改变的时候，所有依赖的对象都会自动收到通知。

观察者模式将观察者和被观察者代码解耦。借助观察者模式，我们可以将很复杂的代码拆分成职责更单一的小类，让其满足开闭原则、高内聚低耦合等特性，以此来控制和应对代码的复杂性，提高代码的可扩展性。

观察者模式的应用场景非常广泛，小到代码层面的解耦，大到架构层面的系统解耦，再或者一些产品的设计思路，都有这种模式的影子，比如邮件订阅本质上都是观察者模式。

举例：
现在有一个业务，当用户注册成功，就向用户发送注册成功的邮件和优惠券，由于邮件优惠券这些功能经常发生变动，所以不能将所有的业务代码都写进注册类中，不然修改起来会很痛苦的

这种情况可以用事件模式(观察者模式)，如下：
找3个人：注册器、路人A、路人B。

注册器：负责将用户信息落库，落库成功之后，喊一声：用户XXX注册成功了。

路人A和路人B，竖起耳朵，当听到有人喊：XXX注册成功的声音之后，立即行动做出下面反应：

路人A：负责给XXX发送一封注册邮件
路人B：负责给XXX发送优惠券

我们来看一下：

注册器只负责将用户信息落库，及广播一条用户注册成功的消息。

A和B相当于一个监听者，只负责监听用户注册成功的消息，当听到有这个消息产生的时候，A和B就去做自己的事情

当不想给用户发送优惠券的时候，只需要将B去掉即可，非常方便

若注册成功之后需要更多业务，比如还需要给用户增加积分，只需新增一个监听者C，监听到注册成功消息后，负责给用户添加积分，此时根本不用去调整注册的代码，开发者和测试人员只需要确保监听者C中的正确性就可以了。

迭代器模式

迭代器模式使用的非常频繁，各大语言基本都有用到
例如java中的Iterator(for each 底层就是用的Iterator)，就是利用的迭代器模式进行遍历

复用&扩展

模版、策略、职责链这三种模式具有相同的作用：复用和扩展

在实际的项目开发中比较常用，特别是框架开发中，我们可以利用它们来提供框架的扩展点，能够让框架的使用者在不修改框架源码的情况下，基于扩展点定制化框架的功能。

模版模式

类似面向对象编程语言里的接口或抽象类的定义：父类定义骨架，子类具体实现

最大的好处：代码复用，减少重复代码。除了子类要实现的特定方法，其他方法及方法调用顺序都在父类中预先写好了。

使用场景：
Spring 中 jdbcTemplate、hibernateTemplate 等以 Template 结尾的对数据库操作的类，它们就使用到了模板模式。

举例：

public abstract class Template {
    //这是我们的模板方法
    public final void TemplateMethod(){
        PrimitiveOperation1();  
        PrimitiveOperation2();
        PrimitiveOperation3();
    }

    protected void  PrimitiveOperation1(){
        //当前类实现
    }
    
    //被子类实现的方法
    protected abstract void PrimitiveOperation2();
    protected abstract void PrimitiveOperation3();

}
public class TemplateImpl extends Template {

    @Override
    public void PrimitiveOperation2() {
        //当前类实现
    }
    
    @Override
    public void PrimitiveOperation3() {
        //当前类实现
    }
}

策略模式

定义：在策略模式中，一个类的行为可以在运行时更改

举例理解： 1、诸葛亮的锦囊妙计，每一个锦囊就是一个策略。 2、旅行的出游方式，每一种旅行方式都是一个策略。

使用场景：
如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。
举例：
在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象。策略对象改变 context 对象的执行算法。

步骤 1
创建一个接口。

public interface Strategy {
   public int doOperation(int num1, int num2);
}

步骤 2
创建实现接口的加减乘除实体类。

public class OperationAdd implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 + num2;
   }
}

public class OperationSubtract implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 - num2;
   }
}

public class OperationMultiply implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 * num2;
   }
}

步骤 3
创建 Context 类。

Context.java
public class Context {
   private Strategy strategy;
 
   public Context(Strategy strategy){
      this.strategy = strategy;
   }
 
   public int executeStrategy(int num1, int num2){
      return strategy.doOperation(num1, num2);
   }
}

步骤 4
使用 Context 来查看当它改变策略 Strategy 时的行为变化。

public class StrategyPatternDemo {
   public static void main(String[] args) {
      Context context = new Context(new OperationAdd());    
      System.out.println("10 + 5 = " + context.executeStrategy(10, 5));
 
      context = new Context(new OperationSubtract());      
      System.out.println("10 - 5 = " + context.executeStrategy(10, 5));
 
      context = new Context(new OperationMultiply());    
      System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
   }
}