行為型設計模式詳解

行為型設計模式是一種設計模式，它關注對象的行為和職責分配。本文將從多個方面詳細闡述行為型設計模式：

一、策略模式

策略模式定義了一組算法，將每個算法分別封裝起來，使它們可以互相替換。策略模式使算法可以獨立於使用它們的客戶端而變化。

策略模式包含以下角色：

• 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"