《设计模式之美》笔记---行为型设计模式

已于 2022-03-14 19:41:10 修改
阅读量1.8k 收藏 1
点赞数
分类专栏： 设计模式 文章标签： 设计模式 java 开发语言
于 2022-03-13 23:21:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liushengxi_root/article/details/123468272
版权

文章目录

观察者模式

极客时间《设计模式之美》笔记—观察者模式

模板模式

模板方法模式在一个方法中定义一个算法骨架，并将某些步骤推迟到子类中实现。模板方法模式可以让子类在不改变算法整体结构的情况下，重新定义算法中的某些步骤。

原理很简单，代码实如下所示。templateMethod()函数定义为final，是为了避免子类重写它。method1()和method2()定义为abstract，是为了强迫子类去实现。

public abstract class AbstractClass {
    // 1. 有些方法又严禁子类实现
    public final void templateMethod() {
        //...
        method1();
        //...
        method2();
        //...
    }

    // 2. 有些逻辑父类做不了主，就交给子类，强迫子类去实现。
    protected abstract void method1();

    //3. 父类实现一些公用的逻辑
    private void parentFun() {
        System.out.println("parent function");
        System.out.println("step 1 ");
        System.out.println("step 2 ");
        System.out.println("step 3 ");
        //4. 有些逻辑再直接交给子类去做，父类直接定义逻辑模板
        method1();
    }

    protected abstract void method2();

    // 5. 有些逻辑父类可以做一部分，最做的就做，但是最好是由子类实现。
    protected void setUp() throws Exception {
        // 父类设置
    }
}

public class ConcreteClass1 extends AbstractClass {
    @Override
    protected void method1() {
        //...
    }

    @Override
    protected void method2() {
        //...
    }
}

public class ConcreteClass2 extends AbstractClass {
    @Override
    protected void method1() {
        //...
    }

    @Override
    protected void method2() {
        //...
    }
}
	// 在这里使用
    AbstractClass demo = ConcreteClass1();
    demo.templateMethod();

模板模式有两大作用：复用和扩展。其中，复用指的是，所有的子类可以复用父类中提供的模板方法的代码。扩展指的是，框架通过模板模式提供功能扩展点，让框架用户可以在不修改框架源码的情况下，基于扩展点定制化框架的功能。

模板模式与回调

策略模式

定义一族算法类，将每个算法分别封装起来，让它们可以互相替换。策略模式可以使算法的变化独立于使用它们的客户端（这里的客户端代指使用算法的代码）。

我们知道，工厂模式是解耦对象的创建和使用，观察者模式是解耦观察者和被观察者。策略模式跟两者类似，也能起到解耦的作用，不过，它解耦的是策略的定义、创建、使用这三部分。接下来，我就详细讲讲一个完整的策略模式应该包含的这三个部分。

定义

public interface Strategy {
  void algorithmInterface();
}

public class ConcreteStrategyA implements Strategy {
  @Override
  public void  algorithmInterface() {
    //具体的算法...
  }
}

public class ConcreteStrategyB implements Strategy {
  @Override
  public void  algorithmInterface() {
    //具体的算法...
  }
}

创建

public class StrategyFactory {
  private static final Map strategies = new HashMap<>();

  static {
    strategies.put("A", new ConcreteStrategyA());
    strategies.put("B", new ConcreteStrategyB());
  }

  public static Strategy getStrategy(String type) {
    if (type == null || type.isEmpty()) {
      throw new IllegalArgumentException("type should not be empty.");
    }
    return strategies.get(type);
  }
}

使用

// 策略接口：EvictionStrategy
// 策略类：LruEvictionStrategy、FifoEvictionStrategy、LfuEvictionStrategy...
// 策略工厂：EvictionStrategyFactory

public class UserCache {
  private Map cacheData = new HashMap<>();
  private EvictionStrategy eviction;

  public UserCache(EvictionStrategy eviction) {
    this.eviction = eviction;
  }

  //...
}

// 运行时动态确定，根据配置文件的配置决定使用哪种策略
public class Application {
  public static void main(String[] args) throws Exception {
    EvictionStrategy evictionStrategy = null;
    Properties props = new Properties();
    props.load(new FileInputStream("./config.properties"));
    String type = props.getProperty("eviction_type");
    evictionStrategy = EvictionStrategyFactory.getEvictionStrategy(type);
    UserCache userCache = new UserCache(evictionStrategy);
    //...
  }
}

// 非运行时动态确定，在代码中指定使用哪种策略
public class Application {
  public static void main(String[] args) {
    //...
    EvictionStrategy evictionStrategy = new LruEvictionStrategy();
    UserCache userCache = new UserCache(evictionStrategy);
    //...
  }
}

如何避免掉冗长的if-else|switch分支判断代码？

//原代码
public class OrderService {
  public double discount(Order order) {
    double discount = 0.0;
    OrderType type = order.getType();
    if (type.equals(OrderType.NORMAL)) { // 普通订单
      //...省略折扣计算算法代码
    } else if (type.equals(OrderType.GROUPON)) { // 团购订单
      //...省略折扣计算算法代码
    } else if (type.equals(OrderType.PROMOTION)) { // 促销订单
      //...省略折扣计算算法代码
    }
    return discount;
  }
}

重构后：

// 策略的定义
public interface DiscountStrategy {
  double calDiscount(Order order);
}
// 省略NormalDiscountStrategy、GrouponDiscountStrategy、PromotionDiscountStrategy类代码...

// 策略的创建
public class DiscountStrategyFactory {
  private static final Map strategies = new HashMap<>();

  static {
    strategies.put(OrderType.NORMAL, new NormalDiscountStrategy());
    strategies.put(OrderType.GROUPON, new GrouponDiscountStrategy());
    strategies.put(OrderType.PROMOTION, new PromotionDiscountStrategy());
  }

  public static DiscountStrategy getDiscountStrategy(OrderType type) {
    return strategies.get(type);
  }
}

// 策略的使用
public class OrderService {
  public double discount(Order order) {
    OrderType type = order.getType();
    DiscountStrategy discountStrategy = DiscountStrategyFactory.getDiscountStrategy(type);
    return discountStrategy.calDiscount(order);
  }
}

但是，如果业务场景需要每次都创建不同的策略对象，我们就要用另外一种工厂类的实现方式了。具体的代码如下所示：

public class DiscountStrategyFactory {
  public static DiscountStrategy getDiscountStrategy(OrderType type) {
    if (type == null) {
      throw new IllegalArgumentException("Type should not be null.");
    }
    if (type.equals(OrderType.NORMAL)) {
      return new NormalDiscountStrategy();
    } else if (type.equals(OrderType.GROUPON)) {
      return new GrouponDiscountStrategy();
    } else if (type.equals(OrderType.PROMOTION)) {
      return new PromotionDiscountStrategy();
    }
    return null;
  }
}

这种实现方式相当于把原来的if-else分支逻辑，从OrderService类中转移到了工厂类中，实际上并没有真正将它移除。

职责链模式

模板模式、策略模式，今天，我们来学习职责链模式。这三种模式具有相同的作用：复用和扩展，在实际的项目开发中比较常用，特别是框架开发中，我们可以利用它们来提供框架的扩展点，能够让框架的使用者在不修改框架源码的情况下，基于扩展点定制化框架的功能。

定义

将请求的发送和接收解耦，让多个接收对象都有机会处理这个请求。将这些接收对象串成一条链，并沿着这条链传递这个请求，直到链上的某个接收对象能够处理它为止。

在职责链模式中，多个处理器（也就是刚刚定义中说的“接收对象”）依次处理同一个请求。一个请求先经过A处理器处理，然后再把请求传递给B处理器，B处理器处理完后再传递给C处理器，以此类推，形成一个链条。链条上的每个处理器各自承担各自的处理职责，所以叫作职责链模式。

实现

第一种

public abstract class Handler {
    protected Handler successor = null;

    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }

    public abstract void handle();
}

public class HandlerA extends Handler {
    @Override
    public void handle() {
        boolean handled = false;
        //真实业务逻辑
        if (!handled && successor != null) {
            successor.handle();
        }
    }
}

public class HandlerB extends Handler {
    @Override
    public void handle() {
        boolean handled = false;
        //真实业务逻辑
        //注意下面的这个设置其实是与业务无关的，所以完全可以提取出来，写为一个模板模式！！！
        if (!handled && successor != null) {
            successor.handle();
        }
    }
}

public class HandlerChain {
    private Handler head = null;
    private Handler tail = null;

    public void addHandler(Handler handler) {
        handler.setSuccessor(null);

        if (head == null) {
            head = handler;
            tail = handler;
            return;
        }

        tail.setSuccessor(handler);
        tail = handler;
    }

    public void handle() {
        if (head != null) {
            head.handle();
        }
    }
}

// 使用举例
public class Application {
    public static void main(String[] args) {
        HandlerChain chain = new HandlerChain();
        //有顺序的处理器链条
        chain.addHandler(new HandlerA());
        chain.addHandler(new HandlerB());
        chain.handle();
    }
}

重构为模板模式后：

public abstract class Handler {
  protected Handler successor = null;

  public void setSuccessor(Handler successor) {
    this.successor = successor;
  }

  public final void handle() {
    boolean handled = doHandle();
    if (successor != null && !handled) {
      successor.handle();
    }
  }

  protected abstract boolean doHandle();
}

public class HandlerA extends Handler {
  @Override
  protected boolean doHandle() {
    boolean handled = false;
    //...
    return handled;
  }
}

public class HandlerB extends Handler {
  @Override
  protected boolean doHandle() {
    boolean handled = false;
    //...
    return handled;
  }
}

// HandlerChain和Application代码不变

第二种(其实就是使用数组实现而已)

public interface IHandler {
  boolean handle();
}

public class HandlerA implements IHandler {
  @Override
  public boolean handle() {
    boolean handled = false;
    //...
    return handled;
  }
}

public class HandlerB implements IHandler {
  @Override
  public boolean handle() {
    boolean handled = false;
    //...
    return handled;
  }
}

public class HandlerChain {
  private List handlers = new ArrayList<>();

  public void addHandler(IHandler handler) {
    this.handlers.add(handler);
  }

  public void handle() {
    for (IHandler handler : handlers) {
      boolean handled = handler.handle();
      if (handled) {
        break;
      }
    }
  }
}

// 使用举例
public class Application {
  public static void main(String[] args) {
    HandlerChain chain = new HandlerChain();
    chain.addHandler(new HandlerA());
    chain.addHandler(new HandlerB());
    chain.handle();
  }
}

应用场景

  • 符合开闭原则
  • 将大块代码逻辑拆分成函数，将大类拆分成小类，是应对代码复杂性的常用方法

迭代器模式

用来遍历集合对象。这里说的“集合对象”也可以叫“容器”“聚合对象”，实际上就是包含一组对象的对象，比如数组、链表、树、图、跳表。迭代器模式将集合对象的遍历操作从集合类中拆分出来，放到迭代器类中，让两者的职责更加单一。

迭代器是用来遍历容器的，所以，一个完整的迭代器模式一般会涉及容器和容器迭代器两部分内容。为了达到基于接口而非实现编程的目的，容器又包含容器接口、容器实现类，迭代器又包含迭代器接口、迭代器实现类。

在这里插入图片描述

实现

// 接口定义
public interface Iterator {
  boolean hasNext();
  void next();
  E currentItem();
}
public class ArrayIterator implements Iterator {
  private int cursor;
  private ArrayList arrayList;
	// 返回一个迭代器类
  public Iterator iterator() {
    return new ArrayIterator(this);
  }

  @Override
  public boolean hasNext() {
    return cursor != arrayList.size(); //注意这里，cursor在指向最后一个元素的时候，hasNext()仍旧返回true。
  }

  @Override
  public void next() {
    cursor++;
  }

  @Override
  public E currentItem() {
    if (cursor >= arrayList.size()) {
      throw new NoSuchElementException();
    }
    return arrayList.get(cursor);
  }
}

public class Demo {
  public static void main(String[] args) {
    ArrayList names = new ArrayList<>();
    names.add("xzg");
    names.add("wang");
    names.add("zheng");

    Iterator iterator = names.iterator();
    while (iterator.hasNext()) {
      System.out.println(iterator.currentItem());
      iterator.next();
    }
  }
}

总结下来就三句话：迭代器中需要定义hasNext()、currentItem()、next()三个最基本的方法。待遍历的容器对象通过依赖注入传递到迭代器类中。容器通过iterator()方法来创建迭代器。

使用场景和优势

  • 对于类似数组和链表这样的数据结构，遍历方式比较简单，直接使用for循环来遍历就足够了。但是，对于复杂的数据结构（比如树、图）来说，有各种复杂的遍历方式。比如，树有前中后序、按层遍历，图有深度优先、广度优先遍历等等。如果由客户端代码来实现这些遍历算法，势必增加开发成本，而且容易写错。如果将这部分遍历的逻辑写到容器类中，也会导致容器类代码的复杂性。
    前面也多次提到，应对复杂性的方法就是拆分。我们可以将遍历操作拆分到迭代器类中。比如，针对图的遍历，我们就可以定义DFSIterator、BFSIterator两个迭代器类，让它们分别来
    实现深度优先遍历和广度优先遍历    。
  • 创建多个不同的迭代器，同时对同一个容器进行遍历而互不影响（这个好像创建多个for循环遍历也能做到，当然其底层就是根绝迭代器实现的嘛）
  • 容器和迭代器都提供了抽象的接口，方便我们在开发的时候，基于接口而非具体的实现编程。当需要切换新的遍历算法的时候，比如，从前往后遍历链表切换成从后往前遍历链表，客户端代码只需要将迭代器类从LinkedIterator切换为ReversedLinkedIterator即可，其他代码都不需要修改。除此之外，添加新的遍历算法，我们只需要扩展新的迭代器类，也更符合开闭原则。
  • 不支持增删元素，如果增删元素之后就会让遍历报错，遍历操作会直接抛出运行时异常。

状态模式

极客时间《设计模式之美》笔记—状态模式

Tattoo_Welkin
关注
专栏目录
设计模式之美—学习笔记
12-07
设计模式之美—学习笔记，纯手打，学习极客时间课程得到。 如有意见或建议，欢迎联系，一起学习讨论。
设计模式之美
aijianxie8808的博客
03-31 250
目录 设计模式分类 设计模式之间的关系 设计模式所支持的设计的可变方面 设计模式怎样解决设计问题 寻找合适的对象 决定对象的粒度 指定对象接口 描述对象的实现 运用复用机制 关联运行时和编译时的结构 设计应支持变化 源代码 设计模式分类 目的 (Purpose) 创建型...
设计模式之美笔记一
碧海潮生
08-23 162
设计模式之美笔记一 本文极客时间课程设计模式之美的个人阅读笔记,有不尽详细之处请抱歉,文未可以订阅极客时间该课程。 什么是面向对象 封装、抽象、继承、多态分别可以解决哪些编程问题？ 封装（Encapsulation） 抽象（Abstraction） 继承（Inheritance） 多态（Polymorphism） 多态特性存在的意义是什么？它能解决什么编程问题？ 设计模式之美 什么是面向对象 OOP：Object Oriented Programming 面向对象编程 OOPL：.
《设计模式之美》笔记
Hasaki
07-15 215
看完了王争哥的《设计模式之美》，质量很高，墙裂推荐。 笔记如图： 对设计模式感兴趣，对代码有强迫症的朋友们，走过路过不要错过，好课值得学习。
设计模式之美笔记1
wjl31802的博客
07-26 472
记录学习王争的设计模式之美 课程 笔记和练习代码，以便回顾复习，共同进步 文章目录1. 为什么要学习设计模式2. 如何评价代码质量的高低1. 简单的描述词汇2. 最常用的评价标准1. 可维护性maintainability2. 可读性readability3. 可扩展性extensibility4. 灵活性 flexibility5. 简洁性 simplicity6. 可复用性reusability7. 可测试性testability3. 最重要的三条3. 面向对象、设计原则、设计模式、编程规范、重构五.
《C++20设计模式》学习笔记-第12章代理模式-配套代码
02-22
《C++20设计模式》学习笔记-第12章代理模式-配套代码
《C++20设计模式》学习笔记-第5章单例模式
02-05
《C++20设计模式》学习笔记-第5章单例模式
《C++20设计模式》学习笔记-第8章组合模式-配套学习代码
02-20
《C++20设计模式》学习笔记-第8章组合模式-配套学习代码
《C++20设计模式》学习笔记-第13章职责链模式-配套代码
最新发布
02-27
《C++20设计模式》学习笔记-第13章职责链模式-配套代码
《C++20设计模式》学习笔记-第11章享元模式-配套代码
02-22
《C++20设计模式》学习笔记-第11章享元模式-配套代码
设计模式之美笔记
u010695169的博客
08-28 339
设计模式
设计模式之美学习笔记
烈冬冰夏的博客
12-25 202
《设计模式之美》学习笔记（一）
錦小白的博客
11-26 319
01.当谈论面向对象的时候，我们到底在谈论什么？ 面向对象编程的英文缩写是 OOP，全称是 Object Oriented Programming 面向对象编程都是通过使用面向对象编程语言来进行的，但是，不用面向对象编程语言，我们照样可以进行面向对象编程。反过来讲，即便我们使用面向对象编程语言，写出来的代码也不一定是面向对象编程风格的，也有可能是面向过程编程风格的 我们没必要纠...
极客时间《设计模式之美》笔记---结构性设计模式
Tattoo的博客
08-09 1059
文章目录设计模式综述代理模式（Proxy Design Pattern）适配器模式桥接模式装饰模式二级目录三级目录 设计模式综述 结构型模式 代理模式（Proxy Design Pattern） 不改变原始类（或叫被代理类）代码的情况下，通过引入代理类来给原始类附加功能 就拿下面这些代码来举例， public class UserController { //...省略其他属性和方法... private MetricsCollector metricsCollector; // 依赖注入
设计模式之美 精华总结 笔记（一）
e935052319的博客
05-13 312
文章目录设计模式之美 笔记（一）一、为什么学习设计模式二、如何评判代码质量的高低三、如何实现高质量代码的编写四、面向对象、设计原则、设计模式、编程规范、重构 五者关系、五、总结 设计模式之美 笔记（一） 一、为什么学习设计模式 1、避免写烂代码 2、提高复杂代码的设计和开发能力 3、读源码、学框架事半功倍 二、如何评判代码质量的高低 常见的形容词： 灵活性(flexibility)、可扩展性(extensibility)、可维护性(maintainability)、可 读性(readability)、可
设计模式笔记：创建型、结构型与行为型模式解析
"设计模式速成笔记" 这篇笔记涵盖了多种设计模式，旨在帮助读者快速理解和掌握设计模式的应用。设计模式是软件工程中经过实践证明的有效解决方案模板，它为常见问题提供了标准化的解决途径，使得开发者可以复用这些...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值