読書メモ：Head Firstデザインパターン（第２版）

public interface FlyBehavior {
  public void fly();
}

public interface QuackBehavior {
  public void quack();
}

public abstract class Duck {
  FlyBehavior flyBehavior;
  QuackBehavior quackBehavior;

  public Duck() {}

  public void performFly() {
    flyBehavior.fly();
  }

  public void performQuack() {
    quackBehavior.quack();
  }

  public void setFlyBehavior(FlyBehavior fb) {
    flyBehavior = fb;
  }

  public void setQuackBehavior(QuackBehavior qb) {
    quackBehavior = qb;
  }
}

public class FlyWithWings implements FlyBehavior {
  public void fly() {
    System.out.println("飛んでいます！！");
  }
}

public class FlyNoWay implements FlyBehavior {
  public void fly() {
    System.out.println("飛べません");
  }
}

public class Quack implements QuackBehavior {
  public void quack() {
    System.out.println("ガーガー");
  }
}

public class MuteQuack implements QuackBehavior {
  public void quack() {
    System.out.println("<<沈黙>>");
  }
}

// 👇 main

public class ModelDuck extends Duck {
  public ModelDuck() {
    flyBehavior = new FlyNoWay();
    quackBehavior = new Quack();
  }
}

public class Main {
  public static void main (String[] args) {
    Duck modelDuck = new ModelDuck();

    modelDuck.performFly();
    modelDuck.performQuack();
    modelDuck.setFlyBehavior(new FlyWithWings());
    modelDuck.performFly();
  }
}

public interface Subject {
  public void registerObserver(Observer o);
  public void removeObserver(Observer o);
  public void notifyObservers();
}

public interface Observer {
  public void update(float temp, float humidity, float pressure);
}

public class WeatherData implements Subject {
  private List<Observer> observers;
  private float temperature;
  private float humidity;
  private float pressure;

  public WeatherData() {
    observers = new ArrayList<Observer>();
  }

  public void registerObserver(Observer o) {
    observers.add(o);
  }

  public void removeObserver(Observer o) {
    observers.remove(o);
  }

  public void notifyObservers() {
    for (Observer observer : observers) {
      observer.update(temperature, humidity, pressure);
    }
  }
}

public class WeatherData implements Subject {
  // ...

  public void notifyObservers() {
    for (Observer observer : observers) {
      observer.update();
    }
  }
}

public interface Observer {
  public void update();
}

public class SomeWeatherDataObserver implements Observer {
  public void update() {
    this.temperature = weatherData.getTemperature();
    this.humidity = weatherData.getHumidity();
    // ...
  }
}

public abstract class Beverage {
  String description = "不明な飲み物";

  public String getDescription() {
    return description;
  }

  public abstract double dost();
}

public abstract class CondimentDecorator extends Beverage {
  Beverage beverage;
  public abstract String getDescription();
}

public class Espresso extends Beverage {
  public Espresso() {
    description = "エスプレッソ";
  }

  public double cost() {
    return 1.99;
  }
}

public class HouseBlend extends Beverage {
  public HouseBlend() {
    description = "ハウスブレンドコーヒー";
  }

  public double cost() {
    return 0.99;
  }
}

public class Mocha extends CondimentDecorator {
  public Mocha(Beverage beverage) {
    this.beverage = beverage;
  }

  public String getDescription() {
    return beverage.getDescription() + "、モカ";
  }

  public double cost() {
    return beverage.cost() + 0.20;
  }
}

public class Mocha extends CondimentDecorator {
  public Mocha(Beverage beverage) {
    this.beverage = beverage;
  }

  public String getDescription() {
    return beverage.getDescription() + "、モカ";
  }

  public double cost() {
    return beverage.cost() + 0.20;
  }
}

// 👇 main

public class CoffeeShop {
  public static void main(String[] args) {
    Beverage beverage1 = new Espresso();
    System.out.println(beverage1.getDescription() + " $" + beverage1.cost());
    // -> エスプレッソ $1.99

    Beverage beverage2 = new DarkRoast();
    beverage2 = new Mocha(beverage2); // モカ
    beverage2 = new Mocha(beverage2); // モカもう一丁（ダブルモカ）
    beverage2 = new Whip(beverage2); // ホイップ
    System.out.println(beverage2.getDescription() + " $" + beverage2.cost());
    // -> ダークローストコーヒー、モカ、モカ、ホイップ $1.49

    Beverage beverage3 = new HouseBlend();
    beverage3 = new Soy(beverage3); // 豆乳
    beverage3 = new Mocha(beverage3); // モカ
    beverage3 = new Whip(beverage3); // ホイップ
    System.out.println(beverage3.getDescription() + " $" + beverage3.cost());
    // -> ハウスブレンドコーヒー、豆乳、モカ、ホイップ $1.34
  }
}

public class SimplePizzaFactory {
  public Pizza createPizza(String type) {
    Pizza pizza = null;

    if (type.equals("チーズ")) {
      pizza = new CheesePizza();
    } else if (type.equals("ペパロニ")) {
      pizza = new PepperoniPizza();
    } else if (type.equals("アサリ")) {
      pizza = new ClamPizza();
    } else if (type.equals("野菜")) {
      pizza = new VeggiePizza();
    }

    return pizza;
  }
}

public class PizzaStore {
  SimplePizzaFactory factory;

  public PizzaStore(SimplePizzaFactory factory) {
    this.factory = factory;
  }

  public Pizza orderPizza(String type) {
    pizza = factory.createPizza(type);

    pizza.prepare();
    pizza.bake();
    pizza.cut();
    pizza.box();

    return pizza;
  }
}

// 👇 main

public class Main {
  public static void main (String[] args) {
    SimplePizzaFactory factory = new SimplePizzaFactory();
    PizzaStore store = new PizzaStore(factory);

    Pizza pizza = store.orderPizza("チーズ");
  }
}

// 👇 abstract
public abstract class PizzaStore {
  public Pizza orderPizza(String type) {
    pizza = createPizza(type);

    pizza.prepare();
    pizza.bake();
    pizza.cut();
    pizza.box();

    return pizza;
  }

  // 👇 Add
  abstract Pizza createPizza(String type);
}

public class NYPizzaStore extends PizzaStore {
  Pizza createPizza(String type) {
    if (type.equals("チーズ")) {
      return new NYStyleCheesePizza();
    } else if (type.equals("ペパロニ")) {
      return new NYStylePepperoniPizza();
    } else if (type.equals("アサリ")) {
      return new NYStyleClamPizza();
    } else if (type.equals("野菜")) {
      return new NYStyleVeggiePizza();
    }
  }
}

// 👇 main

public class Main {
  public static void main (String[] args) {
    PizzaStore nyPizzaStore = new NYPizzaStore();
    PizzaStore chicagoPizzaStore = new ChicagoPizzaStore();

    Pizza nyStorePizza = nyPizzaStore.orderPizza("チーズ");
    Pizza chicagoStorePizza = chicagoPizzaStore.orderPizza("チーズ");
  }
}

public interface PizzaIngredientFactory {
  public Dough createDough();
  public Sauce createSauce();
  public Cheese createCheese();
  public Veggies[] createVeggies();
  public Pepperoni createPepperoni();
  public Clams createClam();
}

public class NYPizzaIngredientFactory implements PizzaIngredientFactory {
  public Dough createDough() {
    return new ThinCrustDough();
  }

  public Sauce createSauce() {
    return new MarinaraSauce();
  }

  public Cheese createCheese() {
    return new ReggianoCheese();
  }

  public Veggies[] createVeggies() {
    return { new Garlic(), new Onion(), new Mushroom(), new RedPepper() };
  }

  public Pepperoni createPepperoni() {
    return new SlicedPepperoni();
  }

  public Clams createClam() {
    return new FreshClams();
  }
}

public abstract class Pizza {
  String name;

  Dough dough;
  Sauce sauce;
  Veggies[] veggies;
  Cheese cheese;
  Pepperoni pepperoni;
  Clams clam;

  abstract void prepare();

  void bake() {
    System.out.println("180度で25分間焼く");
  }

  void cut() {
    System.out.println("ピザを扇形にカットする");
  }

  void box() {
    System.out.println("PizzaStoreの箱にピザを入れる");
  }

  void setName(String name) {
    this.name = name;
  }

  String getName() {
    return name;
  }
}

public class CheesePizza extends Pizza {
  PizzaIngredientFactory ingredientFactory;

  public CheesePizza(PizzaIngredientFactory ingredientFactory) {
    this.ingredientFactory = ingredientFactory;
  }

  void prepare() {
    System.out.println(name + "を下準備");
    dough = ingredientFactory.createDough();
    sauce = ingredientFactory.createSauce();
    cheese = ingredientFactory.createCheese();
  }
}

public class ClamPizza extends Pizza {
  PizzaIngredientFactory ingredientFactory;

  public ClamPizza(PizzaIngredientFactory ingredientFactory) {
    this.ingredientFactory = ingredientFactory;
  }

  void prepare() {
    System.out.println(name + "を下準備");
    dough = ingredientFactory.createDough();
    sauce = ingredientFactory.createSauce();
    cheese = ingredientFactory.createCheese();
    clam = ingredientFactory.createClam();
  }
}

public class NYPizzaStore extends PizzaStore {
  protected Pizza createPizza(String item) {
    Pizza pizza = null;
    PizzaIngredientFactory ingredientFactory = new NYPizzaIngredientFactory();

    if (item.equals("チーズ")) {
      pizza = new CheesePizza(ingredientFactory);
      pizza.setName("ニューヨークスタイルチーズピザ");
    } else if (item.equals("ペパロニ")) {
      pizza = new PepperoniPizza(ingredientFactory);
      pizza.setName("ニューヨークスタイルペパロニピザ");
    } else if (item.equals("アサリ")) {
      pizza = new ClamPizza(ingredientFactory);
      pizza.setName("ニューヨークスタイルアサリピザ");
    } else if (item.equals("野菜")) {
      pizza = new VeggiePizza(ingredientFactory);
      pizza.setName("ニューヨークスタイル野菜ピザ");
    }

    return pizza;
  }
}

// 👇 main

public class Main {
  public static void main (String[] args) {
    PizzaStore nyPizzaStore = new NYPizzaStore();

    Pizza nyStorePizza = nyPizzaStore.orderPizza("チーズ");
    // 👇
    // orderPizza() メソッドのなかで createPizza() メソッドが呼び出される
    // createPizza() メソッドの中で食材ファクトリが実行される
    // -> PizzaIngredientFactory ingredientFactory = new NYPizzaIngredientFactory();
    // -> pizza = new CheesePizza(ingredientFactory);
    // -> pizza.prepare();
    // -> -> dough = ingredientFactory.createDough();
    // -> -> sauce = ingredientFactory.createSauce();
    // -> -> cheese = ingredientFactory.createCheese();
  }
}

public abstract class PizzaStore {
  public Pizza orderPizza(String type) {
    pizza = createPizza(type);
    // ...
    return pizza;
  }

  abstract Pizza createPizza(String type);
}

public class NYPizzaStore extends PizzaStore {
  // 👇（PizzaStoreから見て）サブクラスである NYPizzaStore にオブジェクト作成用のメソッドを委ねる
  Pizza createPizza(String type) {
    if (type.equals("チーズ")) {
      return new NYStyleCheesePizza();
    } else if (/* ... */) {
      // ...
    }
  }
}

public interface PizzaIngredientFactory {
  public Dough createDough();
  public Sauce createSauce();
  public Cheese createCheese();
  // ...
}

public class NYPizzaIngredientFactory implements PizzaIngredientFactory {
  public Dough createDough() {
    return new ThinCrustDough();
  }

  public Sauce createSauce() {
    return new MarinaraSauce();
  }

  public Cheese createCheese() {
    return new ReggianoCheese();
  }

  // ...
}

public class CheesePizza extends Pizza {
  PizzaIngredientFactory ingredientFactory;

  // 👇コンポジションの形でファクトリを受け取る
  public CheesePizza(PizzaIngredientFactory ingredientFactory) {
    this.ingredientFactory = ingredientFactory;
  }

  void prepare() {
    dough = ingredientFactory.createDough();
    sauce = ingredientFactory.createSauce();
    cheese = ingredientFactory.createCheese();
    // ...
  }
}

public class NYPizzaStore extends PizzaStore {
  protected Pizza createPizza(String item) {
    Pizza pizza = null;
    PizzaIngredientFactory ingredientFactory = new NYPizzaIngredientFactory();

    if (type.equals("チーズ")) {
      pizza = new CheesePizza(ingredientFactory);
    } else if (/* ... */) {
      // ...
    }

    return pizza;
  }
}

public class Singleton {
  private static Singleton uniqueInstance;

  private Singleton() {}

  public static Singleton getInstance() {
    if (uniqueInstance == null) {
      uniqueInstance = new Singleton();
    }
    return uniqueInstance;
  }
}

public class Singleton {
  private static Singleton uniqueInstance;

  private Singleton() {}

  // 👇 synchronized キーワードを追加すると、すべてのスレッドはこのスレッドに入る順番を待つ。つまり２つのスレッドが同時にこのメソッドには入れなくなる。
  public static synchronized Singleton getInstance() {
    if (uniqueInstance == null) {
      uniqueInstance = new Singleton();
    }
    return uniqueInstance;
  }
}

public class Singleton {
  // クラスをロードするときにインスタンスを作成する。
  private static Singleton uniqueInstance = new Singleton();

  private Singleton() {}

  public static Singleton getInstance() {
    return uniqueInstance;
  }
}

public class Singleton {
  private volatile static Singleton uniqueInstance;

  private Singleton() {}

  // 👇 まずインスタンスが作成済みか調べたあと、未作成であればそのときは同期的に作成処理を行う。これによりパフォーマンスの懸念も不要になる。
  public static Singleton getInstance() {
    if (uniqueInstance == null) {
      synchronized (Singleton.class) {
        if (uniqueInstance == null) {
          uniqueInstance = new Singleton();
        }
      }
    }
    return uniqueInstance;
  }
}

public interface Command {
  public void execute();
}

public class LightOnCommand implements Command {
  Light light;

  public LightOnCommand(Light light) {
    this.light = light;
  }

  public void execute() {
    light.on();
  }
}

public class SimpleRemoteControl {
  Command slot;
  public SimpleRemoteControl() {}

  public void setCommand(Command command) {
    slot = command;
  }

  public void buttonWasPressed() {
    slot.execute();
  }
}

// 👇 main

public class Main {
  public static void main (String[] args) {
    SimpleRemoteControl remote = new SimpleRemoteControl();
    Light light = new Light();
    LightOnCommand lightOn = new LightOnCommand(light);

    remote.setCommand(lightOn);
    remote.buttonWasPressed();
  }
}

public interface Duck {
  public void quack();
  public void fly();
}

public class MallardDuck implements Duck {
  public void quack() {
    System.out.println("ガーガー");
  }

  public void fly() {
    System.out.println("飛んでいます");
  }
}

// 👇 新しい鳥が登場！

public interface Turkey {
  public void gobble(); // 七面鳥はガーガーとは鳴かず、ゴロゴロ（gobble）と鳴くものです。
  public void fly();
}

public class WildTurkey implements Turkey {
  public void gobble() {
    System.out.println("ゴロゴロ");
  }

  public void fly() {
    System.out.println("飛んでいます");
  }
}

// 👇 Turkey を Duck と同じインタフェースにしたい
public class Turkey Adapter implements Duck {
  Turkey turkey;

  public TurkeyAdapter(Turkey turkey) {
    this.turkey = turkey;
  }

  public void quack() {
    turkey.gobble();
  }

  public void fly() {
    turkey.fly();
  }
}

// 👇 main

public class Main {
  public static void main (String[] args) {
    Duck duck = new MallardDuck();
    testDuck(duck);

    Turkey turkey = new WildTurkey();
    Duck turkeyAdapter = new TurkeyAdapter(turkey);
    testDuck(turkeyAdapter);
  }

  static void testDuck(Duck duck) {
    duck.quack();
    duck.fly();
  }
}

// 👇 ホームシアターで映画を見る準備
public class Main {
  public static void main (String[] args) {
    // （必要な要素をインスタンス化）

    // ポップコーンメーカのスイッチを入れ、作り始める
    popper.on();
    popper.pop();

    // 照明を暗くする
    lights.dim(10);

    // スクリーンを下ろす
    screen.down();

    // プロジェクターの準備
    projector.on();
    projector.setInput(player);
    projector.wideScreenMode();

    // アンプの準備
    amp.on();
    amp.setStreamingPlayer(player);
    amp.setSurroundSound();
    amp.setVolume(5);

    // プレイヤーを操作して上映開始
    player.on();
    player.play(movie);

    // ... 映画を終了する処理
  }
}

// 👇 ファサードで単純化されたインタフェースを提供する。

public class HomeTheaterFacade {
  Amplifier amp;
  Tuner tuner;
  StreamingPlayer player;
  Projector projector;
  TheaterLights lights;
  Screen screen;
  PopcornPopper popper;

  public HomeTheaterFacade(
    Amplifier amp,
    Tuner tuner,
    StreamingPlayer player,
    Projector projector,
    TheaterLights lights,
    Screen screen,
    PopcornPopper popper
  ) {
    this.amp = amp;
    this.tuner = tuner;
    this.player = player;
    this.projector = projector;
    this.screen = screen;
    this.lights = lights;
    this.popper = popper;
  }

  public void watchMovie(String movie) {
    popper.on();
    popper.pop();
    lights.dim(10);
    screen.down();
    projector.on();
    projector.setInput(player);
    projector.wideScreenMode();
    amp.on();
    amp.setStreamingPlayer(player);
    amp.setSurroundSound();
    amp.setVolume(5);
    player.on();
    player.play(movie);
  }

  public void endMovie() {
    popper.off();
    lights.on();
    screen.up();
    projector.off();
    amp.off();
    player.stop();
    player.off();
  }
}

public class Main {
  public static void main (String[] args) {
    // （必要な要素をインスタンス化）

    HomeTheaterFacade homeTheater = new HomeTheaterFacade(
      amp,
      tuner,
      player,
      projector,
      screen,
      lights,
      popper
    );

    homeTheater.watchMovie("レイダース／失われたアーク");
    homeTheater.endMovie();
  }
}

public abstract class Beverage {
  // テンプレートメソッドはサブクラスにオーバーライドされたくないため final。
  final void prepareRecipe() {
    boilWater();
    brew();
    pourInCup();
    addCondiments();
  }

  // 飲み物によって入れ方がことなるので、これはサブクラスに委ねる。
  abstract void brew();

  abstract void addCondiments();

  // 飲み物によらないのでここで定義。ただし必要ならばオーバーライドできる。
  void boilWater() {
    // ...
  }

  void pourInCup() {
    // ...
  }
}

public class Tea extends Beverage {
  public void brew() {
    // ...
  }

  public void addCondiments() {
    // ...
  }
}

public class Coffee extends Beverage {
  public void brew() {
    // ...
  }

  public void addCondiments() {
    // ...
  }
}

// 👇 main

public class Main {
  public static void main (String[] args) {
    Tea myTea = new Tea();
    myTea.prepareRecipe();

    Coffee myCoffee = new Coffee();
    myCoffee.prepareRecipe();
  }
}

public abstract class Beverage {
  final void prepareRecipe() {
    boilWater();
    brew();
    pourInCup();
    addCondiments();
    // 後処理としてサブクラスの任意の処理を実行する機会を与えたい場合はフックを使う
    hook();
  }

  abstract void brew();

  abstract void addCondiments();

  void boilWater() {
    // ...
  }

  void pourInCup() {
    // ...
  }

  // サブクラスでオーバーライドされない限り何もしない
  void hook() {}
}

/**
* Iterator パターン導入前
*/

public class PancakeHouseMenu {
  List<MenuItem> menuItems;

  public PancakeHouseMenu() {
    menuItems = new ArrayList<MenuItem>();
    menuItems.add(new MenuItem(/* ... */));
    menuItems.add(new MenuItem(/* ... */));
    menuItems.add(new MenuItem(/* ... */));
  }

  public ArrayList<MenuItem> getMenuItems() {
    return menuItems;
  }
}

public class DinerMenu {
  static final int MAX_ITEMS = 3;
  MenuItem[] menuItems;

  public DinerMenu() {
    menuItems = new MenuItem[MAX_ITEMS];
    menuItems[0] = new MenuItem(/* ... */);
    menuItems[1] = new MenuItem(/* ... */);
    menuItems[2] = new MenuItem(/* ... */);
  }

  public MenuItem[] getMenuItems() {
    return menuItems;
  }
}

// 👇 main

public class Main {
  public static void main (String[] args) {
    PancakeHouseMenu pancakeHouseMenu = new PancakeHouseMenu();
    ArrayList<MenuItem> breakfastItems = pancakeHouseMenu.getMenuItems();

    DinerMenu dinerMenu = new DinerMenu();
    MenuItem[] lunchItems = dinerMenu.getMenuItems();

    // オブジェクト内部のデータ形式として、前者はリスト、後者は配列で管理しており、
    // getMenuItems() はそのデータ形式のまま返している。
    // そのため両者で取り扱い方が微妙に異なり扱いづらい。
    // 👇

    for (int i = 0; i < breakFastItems.size(); i++) {
      MenuItem menuItem = breakfastItems.get(i);
      // ...
    }

    for (int i = 0; i < lunchItems.length; i++) {
      MenuItem menuItem= lunchItems[i];
      // ...
    }
  }
}

/**
* Iterator パターン導入後
*/

public interface Iterator {
  boolean hasNext();
  MenuItem next();
}

public class DinerMenuIterator implements Iterator {
  MenuItem[] items;
  int position = 0;

  public DinerMenuIterator(MenuItem[] items) {
    this.items = items;
  }

  public MenuItem next() {
    MenuItem menuItem = items[position];
    position = position + 1;
    return menuItem;
  }

  public boolean hasNext() {
    if (position >= items.length || items[position] == null) {
      return false;
    } else {
      return true;
    }
  }
}

public class DinerMenu {
  static final int MAX_ITEMS = 3;
  MenuItem[] menuItems;

  public DinerMenu() {
    menuItems = new MenuItem[MAX_ITEMS];
    menuItems[0] = new MenuItem(/* ... */);
    menuItems[1] = new MenuItem(/* ... */);
    menuItems[2] = new MenuItem(/* ... */);
  }

  public Iterator createIterator() {
    return new DinerMenuIterator(menuItems);
  }
}

// （PancakeHouseMenu も同様に createIterator() で Iterator を返すようにしておく）

// 👇 main

public class Main {
  public static void main (String[] args) {
    PancakeHouseMenu pancakeHouseMenu = new PancakeHouseMenu();
    Iterator pancakeIterator = pancakeHouseMenu.createIterator();

    DinerMenu dinerMenu = new DinerMenu();
    Iterator dinerIterator = dinerMenu.createIterator();

    printMenu(pancakeIterator);
    printMenu(dinerIterator);
  }

  private void printMenu(Iterator iterator) {
    while (iterator.hasNext()) {
      MenuItem menuItem = iterator.next();
      // ...
    }
  }
}

/**
* Iterator パターンの最終形コードの要改善点
*/

public class Main {
  public static void main (String[] args) {
    PancakeHouseMenu pancakeHouseMenu = new PancakeHouseMenu();
    Iterator pancakeIterator = pancakeHouseMenu.createIterator();

    DinerMenu dinerMenu = new DinerMenu();
    Iterator dinerIterator = dinerMenu.createIterator();

    // 👇 メニューを１つずつ個別に管理していることで、新しいメニューが追加されるたびにここのコードを増やす必要がある。
    printMenu(pancakeIterator);
    printMenu(dinerIterator);
  }

  private void printMenu(Iterator iterator) {
    while (iterator.hasNext()) {
      MenuItem menuItem = iterator.next();
      // ...
    }
  }
}

/**
* 👇
* 「すべてのメニュー」があり、その配下に「サブメニュー（PancakeHouseMenu や DinerMenu）」があるようなツリー形式のデータ構造にしたい。
* すべてのメニューに対して操作を行うことができれば、上記のコードは改善される。
*/

// すべてのコンポーネント（ツリーの中のノードとリーフ）は、MenuComponent を実装しなければいけない。
// ただし、ノードとリーフでは異なる役割を持っていることから、どちらかにとっては必要のないメソッドも存在する。
// そのため、デフォルト実装は例外を投げるようにしておく。
// サブクラス（ノードとリーフ）は、サポートする必要のないメソッドはデフォルト実装のままに放っておけばよい。
public abstract class MenuComponent {
  public void add(MenuComponent menuComponent) {
    throw new UnsupportedOperationException();
  }

  public void remove(MenuComponent menuComponent) {
    throw new UnsupportedOperationException();
  }

  public MenuComponent getChild(MenuComponent menuComponent) {
    throw new UnsupportedOperationException();
  }

  public String getName() {
    throw new UnsupportedOperationException();
  }

  public String getDescription() {
    throw new UnsupportedOperationException();
  }

  public double getPrice() {
    throw new UnsupportedOperationException();
  }

  public void print() {
    throw new UnsupportedOperationException();
  }
}

// リーフに相当するクラス。（メニューに載っている商品１つ１つ）
public class MenuItem extends MenuComponent {
  String name;
  String description;
  double price;

  public MenuItem(/* ... */) {
    // ...
  }

  public String getName() {
    return name;
  }

  public String getDescription() {
    return description;
  }

  public String getPrice() {
    return price;
  }

  public void print() {
    System.out.println(getName());
    System.out.println(getDescription());
    System.out.println(getPrice());
  }
}

// ノードに相当するクラス。（すべてのメニューやサブメニュー）
public class Menu extends MenuComponent {
  List<MenuComponent> menuComponent = new ArrayList<MenuComponent>();
  String name;
  String description;

  public Menu(/* ... */) {
    // ...
  }

  public void add(MenuComponent menuComponent) {
    menuComponent.add(menuComponent);
  }

  public void remove(MenuComponent menuComponent) {
    menuComponent.remove(menuComponent);
  }

  public MenuComponent getChild(int i) {
    return menuComponent.get(i);
  }

  public String getName() {
    return name;
  }

  public String getDescription() {
    return description;
  }

  public void print() {
    System.out.println(getName());
    System.out.println(getDescription());
    System.out.println("--------------");

    // 配下のノードの print を再起的に呼び出す。エレガント！
    for (MenuComponent menuComponent : menuComponents) {
      menuComponent.print();
    }
  }
}

// 👇 main

public class Main {
  public static void main (String[] args) {
    MenuComponent allMenus = new Menu("すべてのメニュー");

    PancakeHouseMenu pancakeHouseMenu = new PancakeHouseMenu();
    DinerMenu dinerMenu = new DinerMenu();

    allMenus.add(pancakeHouseMenu);
    allMenus.add(dinerMenu);

    // ツリーの最上位のメニューで print() を呼ぶだけですべてのメニューが表示される
    allMenus.print();
  }
}

/**
* State パターン導入前
*
* 問題点：
* 変更要求があり、新たな状態が増えた場合にすべてのメソッドに手をいれる必要があり、保守が難しい。
*/

public class GumballMachine {
  // QUARTER は 25セント硬貨
  final static int SOLD_OUT = 0; // 売り切れ状態
  final static int NO_QUARTER = 1; // 硬貨投入前状態
  final static int HAS_QUARTER = 2; // 硬貨投入後状態
  final static int SOLD = 3; // 販売処理中状態

  int state = SOLD_OUT;
  int count = 0;

  public GumballMachine(int count) {
    this.count = count;
    if (count > 0) {
      state = NO_QUARTER;
    }
  }

  // 客が25セントを投入しようとします。
  public void insertQuarter() {
    if (state == SOLD_OUT) {
      System.out.println("25セントを投入することはできません。売り切れです。");
    } else if (state == NO_QUARTER) {
      System.out.println("25セントを投入しました。");
      state = HAS_QUARTER;
    } else if (state == HAS_QUARTER) {
      System.out.println("もう１度25セントを投入することはできません。");
    } else if (state == SOLD) {
      System.out.println("お待ちください。ガムボールを出す準備をしています。");
    }
  }

  // 客が25セントを取り出そうとします。
  public void ejectQuarter() {
    if (state == SOLD_OUT) {
      System.out.println("返金できません。まだ25セントを投入していません。");
    } else if (state == NO_QUARTER) {
      System.out.println("25セントを投入していません。");
    } else if (state == HAS_QUARTER) {
      System.out.println("25セントを返却しました。");
      state = NO_QUARTER;
    } else if (state == SOLD) {
      System.out.println("申し訳ありません。すでにハンドルを回しています。");
    }
  }

  // 客がハンドルを回そうとします。
  public void turnCrank() {
    if (state == SOLD_OUT) {
      System.out.println("ハンドルを回しましたが、ガムボールがありません。");
    } else if (state == NO_QUARTER) {
      System.out.println("ハンドルを回しましたが、25セントを投入していません。");
    } else if (state == HAS_QUARTER) {
      System.out.println("ハンドルを回しました。");
      state = SOLD;
    } else if (state == SOLD) {
      System.out.println("２回回してもガムボールをもう１つ手にいれることはできません！");
    }
  }

  // ガムボールを販売します。
  public void dispense() {
    if (state == SOLD_OUT) {
      System.out.println("販売するガムボールはありません。");
    } else if (state == NO_QUARTER) {
      System.out.println("まずお金を払う必要があります。");
    } else if (state == HAS_QUARTER) {
      System.out.println("ハンドルを回す必要があります。");
    } else if (state == SOLD) {
      System.out.println("ガムボールがスロットから出てきます！");
      count = count - 1;
      if (count == 0) {
        System.out.println("おっと、ガムボールがなくなりました！");
        state = SOLD_OUT;
      } else {
        state = NO_QUARTER;
      }
    }
  }
}

/**
* State パターン導入後
*
* - 状態の振る舞いをそれぞれのクラスに局所化した
* - 厄介な if 文をすべてなくした
* - 状態は修正に対して閉じているが、新しい状態クラスを追加することでガムボールマシンは拡張に対して開いている
*/

public interface State {
  public void insertQuarter();
  public void ejectQuarter();
  public void turnCrank();
  public void dispense();
}

public class NoQuarterState implements State {
  GumballMachine gumballMachine;

  public NoQuarterState(GumballMachine gumballMachine) {
    this.gumballMachine = gumballMachine;
  }

  public void insertQuarter() {
    System.out.println("25セントを投入しました。");
    gumballMachine.setState(gumballMachine.getHasQuarterState());
  }

  public void ejectQuarter() {
    System.out.println("25セントを投入していません。");
  }

  public void turnCrank() {
    System.out.println("ハンドルを回しましたが、25セントを投入していません。");
  }

  public void dispense() {
    System.out.println("まずお金を払う必要があります。");
  }
}

public class GumballMachine {
  State soldOutState;
  State noQuarterState;
  State hasQuarterState;
  State soldState;

  State state;
  int count = 0;

  public GumballMachine(int numberGumballs) {
    soldOutState = new SoldOutState(this);
    noQuarterState = new NoQuarterState(this);
    hasQuarterState = new HasQuarterState(this);
    soldState = new SoldState(this);

    this.count = numberGumballs;
    if (numberGumballs > 0) {
      state = noQuarterState;
    } else {
      state = soldOutState;
    }
  }

  public void insertQuarter() {
    state.insertQuarter();
  }

  public void ejectQuarter() {
    state.ejectQuarter();
  }

  public void turnCrank() {
    state.turnCrank();
    state.dispense();
  }

  void setState(State state) {
    this.state = state;
  }

  void releaseBall() {
    System.out.println("ガムボールがスロットから出てきます。");
    if (count != 0) {
      count = count - 1;
    }
  }
}