设计模式双书合参×全图解

class CashFactory {                          // 大话:促销算法工厂(C# 风格)
  static CashSuper create(String type) {
    switch (type) {
      case "rebate": return new CashRebate(0.8);   // 打 8 折
      case "return": return new CashReturn(300, 100); // 满 300 返 100
      default:       return new CashNormal();
    }
  }
}
// HF 同款:SimplePizzaFactory——客户不 new 具体类,只问工厂要

abstract class PizzaStore {                    // HF:把 new 钉在子类
  public Pizza orderPizza(String type) {          // 通用流程:近似模板方法
    Pizza p = createPizza(type);
    p.prepare(); p.bake(); p.cut(); p.box();
    return p;
  }
  protected abstract Pizza createPizza(String type); // 工厂方法:子类说了算
}
class NYPizzaStore extends PizzaStore {
  protected Pizza createPizza(String type) { return new NYStyleCheesePizza(); }
}

interface PizzaIngredientFactory {          // HF:一族原料的合同
  Dough createDough();  Sauce createSauce();  Cheese createCheese();
}
class NYPizzaIngredientFactory implements PizzaIngredientFactory {
  public Dough  createDough()  { return new ThinCrustDough(); }
  public Sauce  createSauce()  { return new MarinaraSauce(); }
}
// 大话:User/Department × SQLServer/Access 两族;加一张新表 = 所有工厂都要动

abstract class PersonBuilder {                 // 大话:画小人(C# 风格)
  protected final Graphics g;
  abstract void buildHead();  abstract void buildBody();
  abstract void buildArmL();  abstract void buildArmR();
  abstract void buildLegL();  abstract void buildLegR();
}
class PersonDirector {                       // 顺序固定在指挥者
  void createPerson(PersonBuilder pb) {
    pb.buildHead(); pb.buildBody();
    pb.buildArmL(); pb.buildArmR();  // 胖/瘦小人只换 Builder,顺序不变
    pb.buildLegL(); pb.buildLegR();
  }
}

class Resume implements Cloneable {         // 大话:简历
  private WorkExperience work;              // 引用字段:浅复制会共享!
  @Override protected Resume clone() {
    Resume r = (Resume) super.clone();      // 浅拷:字段逐位复制
    r.work = (WorkExperience) work.clone(); // 深拷:引用字段再拷一层
    return r;
  }
}

public class ChocolateBoiler {                  // HF:巧克力锅炉
  private static volatile ChocolateBoiler uniq; // 大话:双重锁定也要防指令重排
  private ChocolateBoiler() {}                  // 构造私有
  public static ChocolateBoiler getInstance() {
    if (uniq == null) {                          // 第一次检查:免锁快路径
      synchronized (ChocolateBoiler.class) {
        if (uniq == null) uniq = new ChocolateBoiler(); // 第二次检查
      }
    }
    return uniq;
  }
}

interface Duck { void quack(); void fly(); }
class Turkey {                                     // 火鸡:只会咯咯叫、短距离飞
  void gobble() { }  void fly() { }
}
class TurkeyAdapter implements Duck {          // HF:对象适配器
  private final Turkey turkey;              // 组合而非继承
  public void quack() { turkey.gobble(); }     // 接口翻译
  public void fly()   { for (int i = 0; i < 5; i++) turkey.fly(); }
}

abstract class HandsetSoft {                 // 大话:软件维
  abstract void run();
}
class HandsetGame extends HandsetSoft {
  public void run() { /* 运行游戏 */ }
}
abstract class HandsetBrand {                 // 品牌维:聚合软件
  protected HandsetSoft soft;
  void setSoft(HandsetSoft s) { soft = s; }   // 2 品牌 × 3 软件
  abstract void run();                          // = 6 种组合,零子类爆炸
}

abstract class MenuComponent {                 // HF:菜单树
  void add(MenuComponent c) { throw new UnsupportedOperationException(); }
  abstract void print();
}
class Menu extends MenuComponent {                       // 枝:餐厅菜单/甜点子菜单
  private final List<MenuComponent> children = new ArrayList<>();
  void add(MenuComponent c) { children.add(c); }
  void print() { children.forEach(MenuComponent::print); } // 递归下钻
}

abstract class Beverage {                        // HF:咖啡
  abstract String getDescription();
  abstract double cost();
}
abstract class CondimentDecorator extends Beverage {   // 同类型 + 持有内层
  protected final Beverage beverage;                // 大话:Finery 穿衣服同构
  CondimentDecorator(Beverage b) { this.beverage = b; }
}
class Mocha extends CondimentDecorator {
  Mocha(Beverage b) { super(b); }
  String getDescription() { return beverage.getDescription() + ", Mocha"; }
  double cost() { return .20 + beverage.cost(); }            // 责任层层叠加
}

class HomeTheaterFacade {                         // HF:看电影一键化
  private final Amp amp; private final Dvd dvd; private final Screen screen;
  HomeTheaterFacade(Amp a, Dvd d, Screen s) { amp = a; dvd = d; screen = s; }
  void watchMovie(String movie) {
    screen.down(); amp.on(); dvd.on(); dvd.play(movie);   // 调用次序被封装
  }
  void endMovie() { /* 逆序关闭… */ }
}

class WebSiteFactory {                             // 大话:网站共享
  private final Map<String, WebSite> pool = new HashMap<>();
  WebSite getWebSite(String key) {
    if (!pool.containsKey(key)) pool.put(key, new ConcreteWebSite(key));
    return pool.get(key);                           // 同 key → 同一实例
  }
}
// 内部状态(代码/模板)随实例共享;外部状态(用户 User)调用时作参数传入

interface GiveGift { void giveDolls(); void giveFlowers(); } // 大话:送礼接口
class Pursuit implements GiveGift { /* 男孩本尊 */ }

class Proxy implements GiveGift {          // HF:远程/虚拟/保护,同一副骨架
  private final Pursuit real;
  public void giveDolls() {                     // 「前后插手」的空隙就在这里:
    // 检查权限(保护)/ 确保已加载(虚拟)/ 联网转发(远程)
    real.giveDolls();
  }
}

abstract class CaffeineBeverage {                     // HF:咖啡与茶
  final void prepareRecipe() {                    // 算法骨架锁死
    boilWater(); brew(); pourInCup();
    if (wantsCondiments()) addCondiments();       // 钩子:子类可选干预
  }
  abstract void brew();                          // 变化步骤留给子类
  abstract void addCondiments();
  boolean wantsCondiments() { return true; }        // 缺省钩子
}

interface CashStrategy { double acceptCash(double cash); }   // 大话:收银算法族

class CashContext {                               // HF:鸭子持 FlyBehavior 同构
  private final CashStrategy s;                 // 组合:算法是"装进去"的
  CashContext(CashStrategy s) { this.s = s; }
  double getResult(double cash) { return s.acceptCash(cash); }  // 只委托,不实现
}
// new CashContext(new CashRebate(0.8)).getResult(400) —— 换促销=换策略对象

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

class LightOnCommand implements Command {
  private final Light light;                          // 真正干活的是接收者
  public void execute() { light.on(); }
  public void undo()    { light.off(); }                  // 撤销=反向操作
}
class RemoteControl {                                     // HF 遥控器:调用者只认命令
  private final Command[] onCmds = new Command[7];
  public void setCommand(int slot, Command c) { onCmds[slot] = c; }
  public void onButtonPushed(int slot)  { onCmds[slot].execute(); }
  public void undoButtonPushed(int slot) { onCmds[slot].undo(); }
}

abstract class Manager {                                // 大话:加薪审批链
  protected Manager superior;                          // 下一个处理者
  void setSuperior(Manager m) { superior = m; }
  abstract void requestApplications(Request req);     // 处理不了就上抛
}
// 经理:1 天以内;总监:5 天以内;总经理:10 天以内
// —— 链在哪一环断掉,客户端既不知道也不关心

interface State { void insertQuarter(); void turnCrank(); }   // HF 糖果机

class HasQuarterState implements State {
  private final GumballMachine gumball;             // 状态认识机器
  public void turnCrank() {
    gumball.setState(gumball.getSoldState());           // 自己发起迁移
  }
}

interface Observer { void update(float temp, float humidity); }  // 推模型签名
interface Subject {
  void registerObserver(Observer o);  void removeObserver(Observer o);
  void notifyObservers();
}
class WeatherData implements Subject {                        // HF 气象站
  private final List<Observer> obs = new ArrayList<>();
  public void notifyObservers() { for (Observer o : obs) o.update(temp, humidity); }
  public void measurementsChanged() { notifyObservers(); }       // 数据一变只喊这一嗓子
}

abstract class UnitedNations {                        // 大话:安理会
  abstract void declare(String msg, Country sender);
}
abstract class Country {
  protected final UnitedNations mediator;          // 同事只认识中介
  void send(String msg) { mediator.declare(msg, this); }
}

interface Iterator<T> { boolean hasNext(); T next(); }
class DinerMenuIterator implements Iterator<MenuItem> {
  private final MenuItem[] items;  private int pos = 0;   // 数组也能统一遍历
  public boolean hasNext() { return pos < items.length; }
  public MenuItem next()    { return items[pos++]; }
}
interface Menu { Iterator<MenuItem> createIterator(); }       // 聚合的合同

class GameRole {                                     // 大话:打 Boss 前存档
  private int vit, atk;                            // 状态私有,不开放 setter
  RoleStateMemento save()   { return new RoleStateMemento(vit, atk); }
  void recovery(RoleStateMemento m) { vit = m.getVit(); atk = m.getAtk(); }
}
class RoleStateCaretaker {                          // 管理者:只会存,不会读
  private RoleStateMemento memento;
}

interface Action {                                   // 大话:成功/失败时的反应
  void getManConclusion(Man m);
  void getWomanConclusion(Woman w);
}
abstract class Person { abstract void accept(Action v); }
class Man extends Person {
  void accept(Action v) { v.getManConclusion(this); }    // 双分派第一跳
}
// 加一种反应(如「恋爱」)= 加一个 Visitor 实现;Person 家族零改动

abstract class Expression {                      // 大话:音乐解释器
  abstract void interpret(Context ctx);
}
class TerminalNote extends Expression {           // 终结符:音符 O C E G
  void interpret(Context ctx) { /* 取出并演奏一个音符 */ }
}
class Scale extends Expression {                   // 非终结符:组合
  private final Expression[] parts;
  void interpret(Context ctx) { for (Expression e : parts) e.interpret(ctx); }
}