设计模式学习笔记(四)-行为型模式(Behavioral Pattern)

职责链模式(Chain of Responsibility)
- 多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系，将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理他为止
- 典型应用：servlet filter

命令模式(Command)

命令模式是一种对象行为型模式，其别名为动作(Action)模式或事务(Transaction)模式
将一个请求封装为一个对象，从而使我们可用不同的请求对客户进行参数化；
对请求排队或者记录请求日志，以及支持可撤销的操作。
命令模式的本质是对命令进行封装，将发出命令的责任和执行命令的责任分割开

五个角色：

Command: 抽象命令类
ConcreteCommand: 具体命令类：持有一个接受者Receiver的引用，绑定一个特定的操作
Invoker: 调用者
Receiver: 命令接收者
Client:客户类

//抽象命令 public interface Command {  void execute(); } //具体命令：开灯 public class LightOnCommand implements Command {  private Light light;  public LightOnCommand(Light light) {      this.light = light;  }  public void execute() {      light.lightOn();  } } //具体命令：关灯 public class LightOffCommand implements Command {  private Light light;  public LightOffCommand(Light light) {      this.light = light;  }  public void execute() {      light.lightOff();  } } //调用者Invoker public class XiaoAi {  private Command command;  public void setCommand(Command command) {      this.command = command;  }  public void doCommand() {      command.execute();  } } //命令接收者Receiver public class Light {  public void lightOn() {      System.out.println("灯打开了！！");  }  public void lightOff() {      System.out.println("灯关上了！！");  } } //客户类 public class Client {  public static void main(String[] args) {      XiaoAi xiaoAi = new XiaoAi();      Light light = new Light();      System.out.println("帮我把灯开一下！");      LightOnCommand lightOnCommand = new LightOnCommand(light);      xiaoAi.setCommand(lightOnCommand);      xiaoAi.doCommand();       System.out.println("帮我关一下灯！");      LightOffCommand lightOffCommand = new LightOffCommand(light);      xiaoAi.setCommand(lightOffCommand);      xiaoAi.doCommand();  } }

解释器模式(Interpreter)
- 解释器模式是类的行为模式。
- 给定一个语言之后，解释器模式可以定义出其文法的一种表示，并同时提供一个解释器。
- 客户端可以使用这个解释器来解释这个语句中的句子。
- 典型应用：解析四则混合运算，解析xml文档
迭代器模式(Iterator)
- 提供一种方法顺序访问一个聚合对象中的各种元素，而又不暴露该对象的内部表示
- 典型应用： Java中的Iterator
中介者模式(Mediator)
- 中介者模式又称为调停者模式，它是一种对象行为型模式。
- 用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
- 典型应用：多人聊天室，MVC架构(controller是中介者)，GUI开发中多界面的引用和控制
- 四个角色：(同事类方法中传入中介者对象)
  - Mediator: 抽象中介者
  - ConcreteMediator: 具体中介者
  - Colleague: 抽象同事类
  - ConcreteColleague: 具体同事类
备忘录模式(Memento)
- 备忘录对象是一个用来存储另外一个对象内部状态的快照(snapshot)的对象。
- 备忘录模式的用意是在不破坏封装的条件下，将一个对象的状态捕捉住，并外部化，存储起来，从而可以在将来适合的时候把这个对象还原到存储起来的状态。
- 典型应用：
  - 0、Session和Cookie的使用都是备忘录模式。
  - 1、后悔药。
  - 2、打游戏时的存档。
  - 3、Windows 里的 ctrl + z。
  - 4、IE 中的后退。
  - 5、数据库的事务管理。
观察者模式(Observer)
- 四个角色：(观察者持有目标对象，并在初始化时向目标注册自己。目标发生变化时，通知观察者)
  - Subject: 目标
  - ConcreteSubject: 具体目标
  - Observer: 观察者
  - ConcreteObserver: 具体观察者
- Java自带接口：Observable, Observer
- vs中介者模式：
  - 中介者(mediator)强调的是同事(colleague)类之间的交互
  - 而观察者(observer)中的目标类(subject)强调是目标改变后对观察者进行统一的通讯

״̬ģʽ(State)

别名为状态对象(Objects for States)，状态模式是一种对象行为型模式
允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类。
状态模式的关键是引入了一个抽象类来专门表示对象的状态，这个类我们叫做抽象状态类，而对象的每一种具体状态类都继承了该类，并在不同具体状态类中实现了不同状态的行为，包括各种状态之间的转换

三个角色：

Context: 环境类
State: 抽象状态类
ConcreteState: 具体状态类

public class Context {  private State state;  public void setState(State state) {      this.state = state;  }  public void request(String sampleParameter) {      state.handle(sampleParameter);  } } public interface State {  public void handle(String sampleParameter); } public class ConcreteStateA implements State {  public void handle(String sampleParameter) {      System.out.println("ConcreteStateA handle ：" + sampleParameter);  } } public class ConcreteStateB implements State {  public void handle(String sampleParameter) {      System.out.println("ConcreteStateB handle ：" + sampleParameter);  } } public class Client {  public static void main(String[] args){      State state = new ConcreteStateB();      Context context = new Context();      context.setState(state);      context.request("test");  } }

策略模式(Strategy)
- 定义一系列算法，将每一个算法封装起来，并让它们可以相互替换。
- 策略模式让算法独立于使用它的客户而变化，也称为政策模式(Policy)。
- 策略模式是一种对象行为型模式。
- vs状态模式：
  - 策略模式将具体策略类暴露出去，调用者需要具体明白每个策略的不同之处以便正确使用。
  - 而状态模式状态的改变是由其内部条件来改变的，与外界无关
  - 状态对象是环境类的一个成员变量，策略对象是环境类的一个方法参数
- 三个角色：
  - Context: 环境类
  - Strategy: 抽象策略类
  - ConcreteStrategy: 具体策略类
模板方法模式(Template Method)
- 一个抽象类公开定义了执行它的方法的方式/模板，其子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行
- 典型实例：servlet中service() doGet() doPost() 方法

访问者模式(Visitor)

五个角色:
- 抽象访问者：为对象结构中的每一个具体元素类声明一个访问操作。
- 具体访问者：实现对每一具体元素的访问方法。
- 抽象元素：声明accept方法，接收访问者的访问操作，通常是抽象类和接口。
- 具体元素：实现accept方法，调用访问者的对应的访问方法。
- 对象结构：存放元素对象并提供遍历方法，可以使用组合模式实现
一种将数据操作与数据结构分离的设计模式
类似Java重载，不同的方法入参就是不同的方法实现

interface Visitor {     void visit(Games games);     void visit(Photos photos); } interface Computer {     void accept(Visitor visitor); }  class ZhangSan implements Visitor {     public void visit(Games games) {         games.play();     }     public void visit(Photos photos) {         photos.watch();     } } class LiSi implements Visitor {     public void visit(Games games) {         games.play();     }     public void visit(Photos photos) {         photos.watch();     } } class Games implements Computer {     public void accept(Visitor visitor) {         visitor.visit(this);     }     public void play() {         System.out.println("play lol");     } } class Photos implements Computer {     public void accept(Visitor visitor) {         visitor.visit(this);     }     public void watch() {         System.out.println("watch scenery photo");     } }  class ObjectStructure {     private List<Computer> computers = new ArrayList<Computer>();     public void action(Visitor visitor) {         computers.forEach(c -> {             c.accept(visitor);         });     }     public void add(Computer computer) {         computers.add(computer);     }      public static void main(String[] args) {         ObjectStructure os = new ObjectStructure();         os.add(new Games());         os.add(new Photos());         // 创建一个访问者         Visitor visitor = new ZhangSan();         os.action(visitor);      } }

来源：博客园

作者：kintanx

链接：https://www.cnblogs.com/kintanx/p/11444399.html

标签

命令模式

状态模式