行为型设计模式详解

行为型设计模式是一种设计模式，它关注对象的行为和职责分配。本文将从多个方面详细阐述行为型设计模式：

一、策略模式

策略模式定义了一组算法，将每个算法分别封装起来，使它们可以互相替换。策略模式使算法可以独立于使用它们的客户端而变化。

策略模式包含以下角色：

• Context：上下文类，负责维护一个对策略对象的引用。
• Strategy：策略接口，定义了所有支持的算法的公共接口。
• ConcreteStrategy：具体策略类，实现了Strategy接口，提供了具体算法的实现。

下面是简单的策略模式示例代码：

interface Strategy {
  execute(): void;
}

class ConcreteStrategyA implements Strategy {
  public execute(): void {
    console.log("Executing strategy A");
  }
}

class ConcreteStrategyB implements Strategy {
  public execute(): void {
    console.log("Executing strategy B");
  }
}

class Context {
  private strategy: Strategy;

  constructor(strategy: Strategy) {
    this.strategy = strategy;
  }

  public setStrategy(strategy: Strategy): void {
    this.strategy = strategy;
  }

  public executeStrategy(): void {
    this.strategy.execute();
  }
}

const context = new Context(new ConcreteStrategyA());
context.executeStrategy(); // 输出 "Executing strategy A"
context.setStrategy(new ConcreteStrategyB());
context.executeStrategy(); // 输出 "Executing strategy B"

二、观察者模式

观察者模式定义了一种一对多的依赖关系，当一个对象状态发生改变时，它的所有依赖者都会收到通知。观察者模式将观察者和主题分离，使它们可以独立地改变和复用。

观察者模式包含以下角色：

• Subject：主题接口，定义了观察者通知机制。
• ConcreteSubject：具体主题类，维护一个观察者列表，提供了添加、删除和通知观察者的方法。
• Observer：观察者接口，定义了更新接口。
• ConcreteObserver：具体观察者类，实现了更新接口。

下面是简单的观察者模式示例代码：

interface Subject {
  attach(observer: Observer): void;
  detach(observer: Observer): void;
  notify(): void;
}

class ConcreteSubject implements Subject {
  private observers: Observer[] = [];
  private state: number;

  public getState(): number {
    return this.state;
  }

  public setState(state: number): void {
    this.state = state;
    this.notify();
  }

  public attach(observer: Observer): void {
    this.observers.push(observer);
  }

  public detach(observer: Observer): void {
    const index = this.observers.indexOf(observer);
    if (index !== -1) {
      this.observers.splice(index, 1);
    }
  }

  public notify(): void {
    for (const observer of this.observers) {
      observer.update();
    }
  }
}

interface Observer {
  update(): void;
}

class ConcreteObserverA implements Observer {
  private subject: ConcreteSubject;

  constructor(subject: ConcreteSubject) {
    this.subject = subject;
    this.subject.attach(this);
  }

  public update(): void {
    console.log(`Observer A: ${this.subject.getState()}`);
  }
}

class ConcreteObserverB implements Observer {
  private subject: ConcreteSubject;

  constructor(subject: ConcreteSubject) {
    this.subject = subject;
    this.subject.attach(this);
  }

  public update(): void {
    console.log(`Observer B: ${this.subject.getState()}`);
  }
}

const subject = new ConcreteSubject();
const observerA = new ConcreteObserverA(subject);
const observerB = new ConcreteObserverB(subject);
subject.setState(1); // 输出 "Observer A: 1" 和 "Observer B: 1"
subject.setState(2); // 输出 "Observer A: 2" 和 "Observer B: 2"
subject.detach(observerA);
subject.setState(3); // 输出 "Observer B: 3"

三、责任链模式

责任链模式将请求的发送者和接收者解耦，使多个对象都有机会处理该请求。该模式将这些对象串成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

责任链模式包含以下角色：

• Handler：处理器接口，定义了处理请求的方法和设置下一个处理器的方法。
• ConcreteHandler：具体处理器类，实现了处理请求的方法。
• Client：客户端类，负责创建责任链并将请求发送给它的第一个处理器。

下面是简单的责任链模式示例代码：

abstract class Handler {
  protected successor: Handler;

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

  public abstract handleRequest(request: number): void;
}

class ConcreteHandler1 extends Handler {
  public handleRequest(request: number): void {
    if (request >= 0 && request = 10 && request = 20 && request < 30) {
      console.log(`${this.constructor.name} handled request ${request}`);
    } else if (this.successor) {
      this.successor.handleRequest(request);
    }
  }
}

const handler1 = new ConcreteHandler1();
const handler2 = new ConcreteHandler2();
const handler3 = new ConcreteHandler3();
handler1.setSuccessor(handler2);
handler2.setSuccessor(handler3);

handler1.handleRequest(5); // 输出 "ConcreteHandler1 handled request 5"
handler1.handleRequest(15); // 输出 "ConcreteHandler2 handled request 15"
handler1.handleRequest(25); // 输出 "ConcreteHandler3 handled request 25"
handler1.handleRequest(35); // 什么都不输出

四、命令模式

命令模式将请求封装成一个对象，使得可以使用不同的请求、队列或日志来参数化其他对象。命令模式可以支持撤销操作。

命令模式包含以下角色：

• Command：命令接口，定义了执行和撤销命令的方法。
• ConcreteCommand：具体命令类，实现了命令接口，保存了一个执行者对象。
• Receiver：执行者接口，定义了各种命令的执行方法。
• ConcreteReceiver：具体执行者类，实现了执行者接口，提供了命令的实际执行代码。
• Invoker：调用者类，保存了一组命令，可以按顺序执行它们。

下面是简单的命令模式示例代码：

interface Command {
  execute(): void;
  undo(): void;
}

class ConcreteCommandA implements Command {
  private receiver: ReceiverA;

  constructor(receiver: ReceiverA) {
    this.receiver = receiver;
  }

  public execute(): void {
    this.receiver.actionA();
  }

  public undo(): void {
    this.receiver.undoActionA();
  }
}

class ConcreteCommandB implements Command {
  private receiver: ReceiverB;

  constructor(receiver: ReceiverB) {
    this.receiver = receiver;
  }

  public execute(): void {
    this.receiver.actionB();
  }

  public undo(): void {
    this.receiver.undoActionB();
  }
}

interface ReceiverA {
  actionA(): void;
  undoActionA(): void;
}

class ConcreteReceiverA implements ReceiverA {
  private state: string;

  public actionA(): void {
    console.log("ConcreteReceiverA doing actionA");
    this.state = "actionA";
  }

  public undoActionA(): void {
    console.log(`ConcreteReceiverA undoing ${this.state}`);
  }
}

interface ReceiverB {
  actionB(): void;
  undoActionB(): void;
}

class ConcreteReceiverB implements ReceiverB {
  private state: string;

  public actionB(): void {
    console.log("ConcreteReceiverB doing actionB");
    this.state = "actionB";
  }

  public undoActionB(): void {
    console.log(`ConcreteReceiverB undoing ${this.state}`);
  }
}

class Invoker {
  private commands: Command[] = [];

  public addCommand(command: Command): void {
    this.commands.push(command);
  }

  public executeCommands(): void {
    for (const command of this.commands) {
      command.execute();
    }
  }

  public undoCommands(): void {
    for (const command of this.commands.reverse()) {
      command.undo();
    }
  }
}

const receiverA = new ConcreteReceiverA();
const receiverB = new ConcreteReceiverB();
const commandA = new ConcreteCommandA(receiverA);
const commandB = new ConcreteCommandB(receiverB);
const invoker = new Invoker();
invoker.addCommand(commandA);
invoker.addCommand(commandB);
invoker.executeCommands(); // 输出 "ConcreteReceiverA doing actionA" 和 "ConcreteReceiverB doing actionB"
invoker.undoCommands(); // 输出 "ConcreteReceiverB undoing actionB" 和 "ConcreteReceiverA undoing actionA"