设计模式

• 叶节点: 树根的实现, 没有子元素.
• 容器: 树根的实现, 可以容纳树根作为子元素, 在调用树根定义的方法时, 会遍历调用其子元素的相同方法.

• 保存被装饰对象
• 提供新功能

• 延迟被代理对象的初始化(通常是很重的对象).
• 访问控制.
• 执行远程过程调用.
• 记录日志.

• next字段用来保存下一个命令对象
• setNext方法用来设置下一个命令对象
• handle方法会执行动作, 视具体情况也可以选择拒绝处理.
  此方法会检查next字段是否存在, 如果存在, 则继续调用next.handle, 视具体情况也可以拒绝继续处理.

// 创建处理者
h1 = new HandlerA()
h2 = new HandlerB()
h3 = new HandlerC()
// 形成职责链
h1.setNext(h2)
h2.setNext(h3)
// 执行
h1.handle(request)

// 未重构
function handleInput() {
  if (isPressed(BUTTON_A)) jump()
  else if (isPressed(BUTTON_B)) fire()
  else if (isPressed(BUTTON_X)) swapWeapon()
  else if (isPressed(BUTTON_Y)) heal()
}
// 非OOP重构, 提取成函数
function handleInput() {
  if (isPressed(BUTTON_A)) handleButtonA()
  else if (isPressed(BUTTON_B)) handleButtonB()
  else if (isPressed(BUTTON_X)) handleButtonX()
  else if (isPressed(BUTTON_Y)) handleButtonY()
}
// OOP重构, 提取成方法
// 这要好于非OOP版本, 因为按钮实例在内部还可以运用策略模式
function handleInput() {
  if (isPressed(BUTTON_A)) ButtonA.execute()
  else if (isPressed(BUTTON_B)) ButtonB.execute()
  else if (isPressed(BUTTON_X)) ButtonX.execute()
  else if (isPressed(BUTTON_Y)) ButtonY.execute()
}

interface Iterator<T> {
  getNext(): T
  hasMore(): boolean
}

interface Mediator<T> {
  notify(sender: T, event: string): void
}
class DialogMediator implements Mediator<Button> {
  confirmButton: Button
  cancelButton: Button
  dialogWindow: Window
  
  notify(sender: Button, event: string) {
    if (sender === this.confirmButton && event === 'click') {
      doSomething()
      this.dialogWindow.close()
    }
    if (sender === this.cancelButton && event === 'click') {
      this.dialogWindow.close()
    }
  }
}
class confirmButton implements Button {
  mediator: Mediator
  click() {
    this.mediator.notify(this, 'click')
  }
}
class cancelButton implements Button {
  mediator: Mediator
  click() {
    this.mediator.notify(this, 'click')
  }
}

• save方法返回一个Memento对象, 该对象包含其原发器(Originator, 也就是目标对象本身)当前的所有状态.
• restore方法接收一个Memento对象, 对原发器进行操作, 恢复所有状态.

• 所有状态对象事先实例化好, 添加进状态机, 状态变更只需要向状态机发送事件/下一个状态的名字.
  这适用于状态对象的内部状态需要保留的情况.
• 下一个状态对象由发起状态变更者创建, 这种设计保留了最大的灵活性.

public interface IState {
  void Update(float dt);
  void HandleInput();
  // 进入状态时的钩子, 如果需要重用状态对象, 则在进入状态时可以通过此钩子的参数传入上下文对象.
  void Enter();
  // 退出状态的钩子.
  void Exit();
}
public class EmptyState : IState {
  public void Update(float dt) {}
  public void HandleInput() {}
  public void Enter() {}
  public void Exit() {}
}
public class MoveState : IState {
  private Character char;
  MoveState(Character char) {
    this.char = char;
  }
  
  public void Update(float dt) {
    // ...
  }
  public void HanldeInput() {
    // ...
  }
  
  public void Enter() {
    // ...
  }
  
  public void Exit() {
    // ...
  }
}
public class StateMachine {
  private Dictionary<string, IState> stateMap = new Dictionary<string, IState>();
  private IState currentState = new EmptyState();
  public void Add(string name, IState state) {
    stateMap.Add(name, state);
  }
  public void Remove(string name) {
    stateMap.Remove(name);
  }
  public void ChangeState(string name) {
    currentState.Exit();
    IState nextState = stateMap[name];
    nextState.Enter();
    currentState = nextState;
  }
  public void Update(float dt) {
    currentState.Update(dt);
  }
  public void HandleInput() {
    currentState.HandleInput();
  }
}