head-first-design-pattern

• Duck是superclass
• 在其内部就实现了quack()和swim()
• 而把display()设计成abstract的, 因为所有的子类型display出来都是不同的.

       破坏了"code reuse": 因为java的interface里面的函数都没有实现代
       码,我们要为每个行为在每个subclass里面实现一遍.

Identify the aspects of your application that vary and
spearate them from what statys the same

• 变动的部分: fly, quack这些函数肯定是"变动的部分",要把他们从superclass拿出来
• 不变的部分: display, swim不改变,还留在superclass

• 要么从superclass获取实现(implementation)
• 要么自己实现(implement)一个函数体

Program to an interface, not an implementation

The Strategy Pattern defines a family of algorithms, encapsulates
each one, and makes them interchangeable. Strategy lets the
algorithm vary independently from clients that use it.

Favor composition over inheritance

• 包装一系列的其他类的算法, 却没有继承负担
• 可以在runtime更改行为

• Weather Station: 是物理设备,读取三个参数湿度,温度,气压
• WeatherData Object: 能够从Weather Station读取数据并且传递给Display device
• Display Device: 能够从WeatherData Object那里得到数据并显示.

+---------------------+
|   WeatherData       |
+---------------------+
|getTemperature()     |
|getHumidity()        |
|getPressure()        |
|measurementsChanged()|
|//...                |
+---------------------+

• 我们update Device的方法是,把每个具体的实现(implementation)都放入了函数内 部, 这违反了design principle(Program to an interface, not an implementation) 从而导致无法再runtime 增加或删除display设备
• 既然display设备是有可能"改变的部分",我们要独立出来实现
• 三个display对象的update函数参数都一样,我们最少要让他们实现同一个接口.

The Observer Pattern defines a one-to-many dependency between
objects so that when one object changes state, all of its
dependents are notified and updated automatically.

Strive for loosely coupled designs between objects that interact

• 首先看Subject interface

  package org.hfeng.misc.hfdp.ch2.observer.plain;
  
  public interface Subject {
      public void registerObserver(Observer o);
      public void removeObserver(Observer o);
      public void notifyObservers();
  }
  

• WeatherData实现了这个接口.

  package org.hfeng.misc.hfdp.ch2.observer.plain;
  
  import java.util.ArrayList;
  
  public class WeatherData implements Subject {
      private ArrayList<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) {
          int i = observers.indexOf(o);
          if (i >= 0) {
              observers.remove(i);
          }
      }
  
      public void notifyObservers() {
          for (int i = 0; i < observers.size(); i++) {
              Observer observer = observers.get(i);
              observer.update(temperature, humidity, pressure);
          }
      }
  
      //此函数一般是WeatherStation调用,在更新的情况下,通知所有的observer
      public void measurementsChanged() {
          notifyObservers();
      }
  
      public void setMeasurements(float temperature, float humidity, float pressure) {
          this.temperature = temperature;
          this.humidity = humidity;
          this.pressure = pressure;
          measurementsChanged();
      }
  }
  

• Observer interface的代码如下

  package org.hfeng.misc.hfdp.ch2.observer.plain;
  
  public interface Observer {
      public void update(float temperature, float humidity, float pressure);
  }
  

• DisplayElement interface的代码如下

  package org.hfeng.misc.hfdp.ch2.observer.plain;
  
  public interface DisplayElement {
      void display();
  }
  

• 任意一个display都可以如下的实现上面两个接口, 我们以其中一个display为例,其 他display都类似

  package org.hfeng.misc.hfdp.ch2.observer.plain;
  
  public class CurrentConditionDisplay implements Observer, DisplayElement {
      private float temperate;
      private float humidity;
      // 包含了一个指向ConcreteSubject的ref, 这样可以在ctor的时候注册进去.
      // 当然也可以明确的在"外部"注册."内部"注册反而更不容易错
      private Subject weatherData;
  
      public CurrentConditionDisplay(Subject weatherData){
          this.weatherData = weatherData;
          weatherData.registerObserver(this);
      }
      public void update(float temperature, float humidity, float pressure) {
          this.temperate = temperature;
          this.humidity = humidity;
          display();
      }
  
      public void display() {
          System.out.println("Current condition: " + temperate
                             + "F degree and " + humidity + "% humidity");
      }
  }
  

• 好,我们最后来写个main例子来测试我们的display

  package org.hfeng.misc.hfdp.ch2.observer.plain;
  
  public class WeatherStation {
      public static void main(String[] args) {
          WeatherData weatherData = new WeatherData();
  
          CurrentConditionsDisplay currentConditionsDisplay = new CurrentConditionsDisplay(weatherData);
          StatisticsDisplay statisticsDisplay = new StatisticsDisplay(weatherData);
          ForecastDisplay forecastDisplay = new ForecastDisplay(weatherData);
          weatherData.setMeasurements(80, 65, 30.4f);
          System.out.println();
          weatherData.setMeasurements(82, 70, 29.2f);
      }
  }
  
  ////////////////////////////////////////////////////////
  // <===================OUTPUT===================>     //
  // Current condition: 80.0F degree and 65.0% humidity //
  // Avg/Max/Min temperate = 80.0/80.0/80.0             //
  // Forecast: Improving weather on the day             //
  //                                                    //
  // Current condition: 82.0F degree and 70.0% humidity //
  // Avg/Max/Min temperate = 81.0/82.0/80.0             //
  // Forecast: Watch out for cooler, rainy weather      //
  ////////////////////////////////////////////////////////
  

• 观察者这边是interface Observer:

  package org.hfeng.misc.hfdp.ch2.observer.observable;
  
  import java.util.Observable;
  import java.util.Observer;
  
  public class CurrentConditionsDisplay implements Observer, DisplayElement {
      Observable observable;
      private float temperature;
      private float humidity;
  
      public CurrentConditionsDisplay(Observable observable) {
          this.observable = observable;
          observable.addObserver(this);
      }
  
      public void update(Observable obs, Object arg) {
          if (obs instanceof WeatherData) {
              WeatherData weatherData = (WeatherData)obs;
              this.temperature = weatherData.getTemperature();
              this.humidity = weatherData.getTemperature();
              display();
          }
      }
      public void display() {
          System.out.println("Current conditions: " + temperature + "F degrees and "
                  + humidity + "% humidity");
      }
  }
  

• 订阅者这边是class Observable:

  package org.hfeng.misc.hfdp.ch2.observer.observable;
  
  import java.util.Observable;
  
  public class WeatherData extends Observable {
      public float getTemperature() {
          return temperature;
      }
  
      public float getHumidity() {
          return humidity;
      }
  
      public float getPressure() {
          return pressure;
      }
  
      private float temperature;
      private float humidity;
      private float pressure;
  
      public WeatherData(){ }
  
      public void measurementsChanged() {
          setChanged();
          notifyObservers();
      }
  
      public void setMeasurements(float temperature, float humidity, float pressure) {
          this.temperature = temperature;
          this.humidity = humidity;
          this.pressure = pressure;
          measurementsChanged();
      }
  }
  

• 用户使用

  package org.hfeng.misc.hfdp.ch2.observer.observable;
  
  public class WeatherStation {
      public static void main(String[] args) {
          WeatherData weatherData = new WeatherData();
          CurrentConditionsDisplay currentConditionDisplay =
              new CurrentConditionsDisplay(weatherData);
          StatisticsDisplay statisticsDisplay = new StatisticsDisplay(weatherData);
          ForecastDisplay forecastDisplay = new ForecastDisplay(weatherData);
  
          weatherData.setMeasurements(82, 70, 29.2f);
          System.out.println();
          weatherData.setMeasurements(82, 70, 29.2f);
      }
  }
  
  //////////////////////////////////////////////////////////
  // <===================OUTPUT===================>       //
  // Forecast: Watch out for cooler, rainy weather        //
  // Avg/Max/Min temperate = 82.0/82.0/82.0               //
  // Current conditions: 82.0F degrees and 82.0% humidity //
  //                                                      //
  // Forecast: More of the same                           //
  // Avg/Max/Min temperate = 82.0/82.0/82.0               //
  // Current conditions: 82.0F degrees and 82.0% humidity //
  //////////////////////////////////////////////////////////
  

• 你必须首先设置内部的state为changed,然后才能进行notify
• measurementsChanged()按说是被调用者使用的,这里被setMeasurements包含,然后 被用户调用
• IMPORTANT! 这次display的顺序和上次不同! 上次是按照我们注册的顺序C->A->F, 而这次顺序却反过来了!F->A-C, 这是因为java实现时候的notify顺序和我们的不同 所以

  Never depend on order of evaluation of the Observer notifications
  

• Observable is a class:
  1. 这没有必要,因为我们必须继承Observerable, 而我们如果已经有一套成熟代码 的情况下想"获取Observable这种能力",那么我们implement接口就好了(脑补 Runnable), 但是设计成class就没办法了
  2. 你甚至不能提供自己的observable实现,比如多线程安全版本的
• Observable 的关键函数的protected的: 如果你看了代码你会发现Observable最关键的函数setChanged()是protected,这就 说明你必须得subclass才能调用,连composition这条路都堵上了.

Classes should be open for extension, but closed for modification.

• 我们有个基本的咖啡DarkRoast
• 第一步"装饰": Mocha
• 第二步"装饰": Whip
• 这样一来调用cost()的时候,就可以根据装饰的过程来计算最后的价格

• Beverage就是component
• Espresso等咖啡就是具体的component(ConcreteComponent)
• Milk, Soy等"作料"也想成为和Espresso等一样的Concretecomponent,无奈自己能力 有限,所以要依靠decorator
• CondimentDecorator(作料decorator), 把自己装扮成"ConcreteComponent"

• Beverage就是一个abstract class

  package org.hfeng.misc.hfdp.ch3.starbuzz;
  
  public abstract class Beverage {
      String description = "Unknown Beverage";
  
      public String getDescription() {
          return description;
      }
  
      public abstract double cost();
  }
  

• Espresso是具体的咖啡,是咖啡店的主力

  package org.hfeng.misc.hfdp.ch3.starbuzz;
  
  public class Espresso extends Beverage {
      public Espresso() {
          description = "Espresso";
      }
  
      public double cost() {
          return 1.99;
      }
  }
  

• CondimentDecorator,目的是:让"作料"也有主力咖啡样子的

  package org.hfeng.misc.hfdp.ch3.starbuzz;
  
  public abstract class CondimentDecorator extends Beverage{
      public abstract String getDescription();
  }
  

• Milk是"作料",它继承了CodimentDecorator,从此有了主力咖啡的能力

  package org.hfeng.misc.hfdp.ch3.starbuzz;
  
  public class Milk extends CondimentDecorator {
      Beverage beverage;
  
      public Milk(Beverage beverage) {
          this.beverage = beverage;
      }
  
      public String getDescription() {
          return beverage.getDescription() + ", Milk";
      }
  
      public double cost() {
          return .10 + beverage.cost();
      }
  }
  

• 最后我们来看看测试代码,用法很特别

  package org.hfeng.misc.hfdp.ch3.starbuzz;
  
  public class CoffeeTest {
      public static void main(String[] args) {
          Beverage beverage = new Espresso();
          System.out.println(beverage.getDescription() + " $" + beverage.cost());
  
          Beverage beverage2 = new DarkRoast();
          beverage2 = new Mocha(beverage2);
          beverage2 = new Mocha(beverage2);
          beverage2 = new Whip(beverage2);
          System.out.println(beverage2.getDescription() + " $" + beverage2.cost());
  
          Beverage beverage3 = new HouseBlend();
          beverage3 = new Soy(beverage3);
          beverage3 = new Mocha(beverage3);
          beverage3 = new Whip(beverage3);
          System.out.println(beverage3.getDescription() + " $" + beverage3.cost());
      }
  }
  
  ////////////////////////////////////////////////////
  // <===================OUTPUT===================> //
  // Espresso $1.99                                 //
  // Dark Roast Coffee, Mocha, Mocha, Whip $1.49    //
  // House Blend Coffee, Soy, Mocha, Whip $1.34     //
  ////////////////////////////////////////////////////
  

• 新的类型的"鸭子"可能会加入
• 老的类型的"鸭子"可能会不再支持

• 优点是不需要实例化SimplePizzaFactory就可以使用createPizza
• 缺点是不能通过"继承"SimplePizzaFactory来更改createPizza的实现.

       我们前面讨论的一切叫做`Simple Factory`, 它并不是设计模式的一种!
       介绍它是因为它广泛的存在和使用

• 为了保证自己的产品质量不会因为"新加盟商"的把控不力而砸了牌子
• 每个加盟商都在不同的地区,都有"地区化的特殊"要求,换句话说,会有不同的的 prepare(),或者bake()函数实现

• New York: 就创建个新的NYPizzaFactory
• Chicago: 就创建个新的ChicagoPizzaFactory
• California: 就创建个CaliforniaPizzaFactory

• 我们对于prepare(), bake()等工作要求甚高,不能由"加盟商"实现,所以我们要保护 好这些代码
• 同时我们要给"加盟商"一些选择自己的披萨类型的权利.注意是'选择披萨类型的权利', 而不是'更改烹饪方法的权利'

• 首先factory method必须是abstract的, 所以才能让subclass来进行object的creation 的活动
• 其次,其返回值一般会为superclass所用, superclass也知道其接口
• factoryMethod也是可以有参数的,用来选择不同的类型.

       封装object创建过程: encapsulate object creation

       让子类来决定生产什么样的对象

• Abstract Factory produces Abstract Product
• Concrete Factory produces Concrete Product

The Factory Method Pattern: defines an interface for creating an object,
but lets subclasses decide which class to instantiate, Factory Method lets a
class defer instantiation to subclasses.

Depend upon abstractions. Do not depend upon concrete classes

• "program to interface"更多的是要求high-level使用low-level的时候,要使用 low-level的接口
• 而我们当前的dependency inversion principle要求我们(high-level就是决定 low-level的类,比如这里是store, 而low-level就是pizza:
  1. high-level依赖low-level的接口
  2. low-level也要同时依赖high-level的接口

• No variable should hold a reference to a concrete class: 如果你使用了new的 话, 那么你就hold了一个concrete class的reference,肯定就依赖于这个concrete class, 使用factory来返回一个interface,在runtime来确定是什么concrete class
• No class should derive from a concrete class: 如果你继承一个concrete class, 那么肯定是依赖于这个class, 所以请继承一个interface(或者abstract class)
• No method should override an implementted method of any of its base classes: 依然用到了继承, 而且还是集成的abstract class, 那么base class的method已经实 现了的话,那么subclass是"最好不要"改动implementation,因为一旦改动,这个"is-a" 的关系,就不纯正了.

• 为每一个地区都创建一个PizzaIngredientFactory的subclass来创建"地区特色配料"
• 创建一系列"concrete ingredient", 比如ReggianoCheese, ThinCrustDough这些配 料是可以在不同的地区间分享的(如果一个ingredient每处都可得,当然可以)
• 最后我们还是需要一个PizzaStore来联系所有的东西

The Abstract Factory Pattern provides an interface for creating
families of related or dependent objects without specifying
their concrete classes

• 比如,我们'具体的pizza CheesePizza'就是Abstract Factory的使用者(Client). 在 定义的时候, 内部是看不到concrete class的, PizzaIngredientFactory, dough, sauce, cheese都是interface或者abstract class

  package org.hfeng.misc.hfdp.ch4.factory.abstractf;
  
  public class CheesePizza extends Pizza {
      PizzaIngredientFactory ingredientFactory;
  
      public CheesePizza(PizzaIngredientFactory ingredientFactory) {
          this.ingredientFactory = ingredientFactory;
      }
  
      void prepare() {
          System.out.println("Preparing " + name);
          dough = ingredientFactory.createDough();
          sauce = ingredientFactory.createSauce();
          cheese = ingredientFactory.createCheese();
      }
  

• 只有在runtime使用的时候,才会赋予一个concreteFactory, 从而生产出concretePizza, 注意是在if else里面的new instance的时候,传入一个concreteFactory

  public class NYPizzaStore extends PizzaStore {
      protected Pizza createPizza(String item) {
          Pizza pizza = null;
          PizzaIngredientFactory ingredientFactory =
                  new NYPizzaIngredientFactory();
  
          if (item.equals("cheese")) {
              pizza = new CheesePizza(ingredientFactory);
              pizza.setName("New York Style Cheese Pizza");
          } else if (item.equals("clam")) {
              pizza = new ClamPizza(ingredientFactory);
              pizza.setName("New York Style Clam Pizza");
          }
          return pizza;
      }
  }
  

• 巧克力和牛奶还没有加热就排除
• 锅炉已经满了还往里加牛奶或巧克力
• 加热一个空的锅炉

ChocolateBoiler被实例化了多次!!

The Sinleton Pattern ensures a class has only one instance, and provides a glob
al point of access to it.

• 首先为了能够使问题更容易实现,让getInstance中间休息一秒

  public static ChocolateBoiler getInstance() throws Exception{
      if (uniqueInstance == null) {
          SECONDS.sleep(1);
          System.out.println("Creating unique instance of Chocolate Boiler, should happen only once!");
          uniqueInstance = new ChocolateBoiler();
      }
      System.out.println("Returning instance of Chocolate Boiler");
      return uniqueInstance;
  }
  

• 创建一个允许getInstance()的thread

  package org.hfeng.misc.hfdp.ch5.singleton.notthreadsafe;
  
  public class BoilerRunnable implements Runnable {
      public void run() {
          try {
              ChocolateBoiler.getInstance().fill();
              ChocolateBoiler.getInstance().boil();
          } catch (Exception e) {
              e.printStackTrace();
          }
  
      }
  }
  

• 我们运行三个thread,应该只创建一次object, 从打印信息来看,我们不小心创建了 三次(每个thread都创建了一个object). singleton的承诺,荡然无存

  package org.hfeng.misc.hfdp.ch5.singleton.notthreadsafe;
  
  public class MainTest {
      public static void main(String[] args) {
  
          for (int i = 0; i < 3; i++) {
              new Thread(new BoilerRunnable()).start();
          }
      }
  }
  
  ////////////////////////////////////////////////////////////////////////////
  // <===================OUTPUT===================>                         //
  // Creating unique instance of Chocolate Boiler, should happen only once! //
  // Returning instance of Chocolate Boiler                                 //
  // Filling                                                                //
  // Returning instance of Chocolate Boiler                                 //
  // Creating unique instance of Chocolate Boiler, should happen only once! //
  // Returning instance of Chocolate Boiler                                 //
  // Filling                                                                //
  // Returning instance of Chocolate Boiler                                 //
  // We boiled already! NO MORE Boil should ever happen!                    //
  // Creating unique instance of Chocolate Boiler, should happen only once! //
  // Returning instance of Chocolate Boiler                                 //
  // Filling                                                                //
  // Returning instance of Chocolate Boiler                                 //
  // We boiled already! NO MORE Boil should ever happen!                    //
  // We boiled already! NO MORE Boil should ever happen!                    //
  ////////////////////////////////////////////////////////////////////////////
  

• 让getInstance每次只能有一个thread进入

  public static synchronized ChocolateBoiler getInstance() throws Exception{
      if (uniqueInstance == null) {
          SECONDS.sleep(1);
          System.out.println("Creating unique instance of Chocolate Boiler, should happen only once!");
          uniqueInstance = new ChocolateBoiler();
      }
      System.out.println("Returning instance of Chocolate Boiler");
      return uniqueInstance;
  }
  

• 结果很令人满意

  package org.hfeng.misc.hfdp.ch5.singleton.threadsafe;
  
  public class MainTest {
      public static void main(String[] args) {
  
          for (int i = 0; i < 3; i++) {
              new Thread(new BoilerRunnable()).start();
          }
      }
  }
  
  ////////////////////////////////////////////////////////////////////////////
  // <===================OUTPUT===================>                         //
  // Creating unique instance of Chocolate Boiler, should happen only once! //
  // Returning instance of Chocolate Boiler                                 //
  // Filling                                                                //
  // Returning instance of Chocolate Boiler                                 //
  // Returning instance of Chocolate Boiler                                 //
  // We boiled already! NO MORE Boil should ever happen!                    //
  // Returning instance of Chocolate Boiler                                 //
  // Returning instance of Chocolate Boiler                                 //
  // Returning instance of Chocolate Boiler                                 //
  ////////////////////////////////////////////////////////////////////////////
  

• 如果getInstance()对你的效率影响没有"很重要", 那么,不必要进行improve. synchronized的方式,一般会降低100倍的速度.所以如果经常调用的话,还是要去优化
• 放弃lazy initialization, 当然了,这样就无法做到我们前面说的"expensive的资源 不需要就不创建". 下面的方法,等于使用了JVM的承诺:一定在某个thread到来之前, 初始化好instance

  public class Singleton {
      private static Singleton uniqueInstance = new Singleton();
  
      private Singleton() {}
  
      public static Singleton getInstance() {
          return uniqueInstance;
      }
  }
  

• 使用"double-check lock"来解决synchronized次数多的问题!(After JDK 1.4).注意! 下面的例子使用了两次的check. 综合下来,我们只有第一个thread来的时候需要synchronized. 还要注意的是double check要同时加上volatile,防止编译器为了性能更改'语句'顺序.

  public class Singleton {
      // volatile is needed here
      private volatile static Singleton uniqueInstance;
  
      private Singleton() {}
  
      public static Singleton  getInstance() {
          if (uniqueInstance == null) {
              // synchronized the Singleton.class, other than this!
              synchronized (Singleton.class) {
                  /////////////////////////////////////////////////////////////////
                  // There may be more than one threads waiting outside of the   //
                  // synchronized closure, so after the first thread out, the    //
                  // second thread go here may still not know that the           //
                  // uniqueInstance is already created                           //
                  /////////////////////////////////////////////////////////////////
                  if (uniqueInstance == null) {
                      uniqueInstance = new Singleton();
                  }
              }
          }
          return uniqueInstance;
      }
  }
  

• 我们要设计一个remote control
• 这个remote control有七个'可编程槽', 每个槽都有on off的开关
• remote control还有一个全局的undo开关
• 如何控制这些硬件的函数,都已经有了比如
  1. 开:函数on()
  2. 关:函数off()
  3. 其他函数比如setVolumen(), setInputChannel()也是有的,但是显然我们remote control用不到
• 要支持这些函数,同时还要考虑到以后,可能有更多的硬件(最少有on, off函数),要 能够支持.

       设计一个Command object, 我们的remote control和这个Command object交谈,
       而Command object则负责和它对应的设备(可以是Light, TV, DVD中的一种)交谈

• 我们首先创建一个抽象的Command interface
• Remote Control里面就has-one Command Interface (我们把这个叫做Invoker)
• 对于'开'和'关'这两个命令,我们分别要实现两个concreteCommand类
• 这两个concreteCommand类里面要分别has-one 具体的已经存在的Object(这里就是 Light啦), 然后在内部调用已经存在的Object的函数(On或者Off)
• 这样Command Interface和Concrete Command在一起:一边联系了的RemoteControl, 另外一边联系了已经存在了的Object(Light).解除了两者的耦合

• Command Interface

  package org.hfeng.misc.hfdp.ch6.simpleremote;
  
  public interface Command {
      public void execute();
  }
  

• Command Concrete Class(以LightOn为例子, LightOff相似)

  package org.hfeng.misc.hfdp.ch6.simpleremote;
  
  public class LightOnCommand implements Command {
      Light light;
      public LightOnCommand(Light light) {
          this.light = light;
      }
  
      public void execute() {
          light.on();
      }
  }
  

• 被Command联系的一边: 已经存在的Light类代码(已经被前面的LightOnCommand所包 含了,也就是Composition组合)

  package org.hfeng.misc.hfdp.ch6.simpleremote;
  
  public class Light {
      public void on() {
          System.out.println("Light On");
      }
      public void off() {
          System.out.println("Light Off");
      }
  }
  

• 被联系的另外一边,就是remoteControl的代码

  package org.hfeng.misc.hfdp.ch6.simpleremote;
  
  public class SimpleRemoteControl {
      Command slot;
      public SimpleRemoteControl(Command slot) {
          this.slot = slot;
      }
  
      public SimpleRemoteControl() {}
  
      public void setCommand(Command slot) {
          this.slot = slot;
      }
  
      public void press() {
          slot.execute();
      }
  }
  

• 我们最后需要一个Main函数来测试一下

  package org.hfeng.misc.hfdp.ch6.simpleremote;
  
  public class MainTest {
      public static void main(String[] args) {
          Light light = new Light();
          LightOnCommand lightOnCommand = new LightOnCommand(light);
          LightOffCommand lightOffCommand = new LightOffCommand(light);
  
          SimpleRemoteControl SRLightOn = new SimpleRemoteControl();
          SRLightOn.setCommand(lightOnCommand);
          SRLightOn.press();
  
          SimpleRemoteControl SRLightOff = new SimpleRemoteControl();
          SRLightOff.setCommand(lightOffCommand);
          SRLightOff.press();
  
          //All other 6 ONs and 6 OFFs SimpleRemoteControl instances
          //list here ...
      }
  }
  
  ////////////////////////////////////////////////////
  // <===================OUTPUT===================> //
  // Light On                                       //
  // Light Off                                      //
  ////////////////////////////////////////////////////
  

The COmmand Pattern encapsulates a request as an object, thereby  letting
you parameterize other objects wieth different requests, queue or log
requests, and support undoable operations

• Vender为我们提供了一些class的接口让我们来使用, 但是我们已有的代码是无法支 持这些接口的

  

  Figure 20: do-not-match.png

• 我们已有的代码经过测试用例和实际环境的千锤百炼,不能轻易去改,而你又不可能去 更改Vender的代码.那么一个Adapter是一个非常好的选择

  

  Figure 21: adapter-between.png

The Adapter Pattern converts the interface of a class into another
interface the clients expect. Adapter lets classes work together that
couldn't otherwise becasue of incompatible interfaces

• object adapter, 也就是我们前面使用的.是使用composition来完成adapt的

  

  Figure 23: object-adapter.png

• class adapter, 是使用多重继承来完成adapt的, 这在java里面无法实现, c++里面 可以. 但是显然不如composition的来的更为灵活

  

  Figure 24: class-adapter.png

• Java早期的collection(比如Vector, Stack Hashtable等)都implement了一个interface Enumeration. 这个interface有两个函数hasMoreElements()和nextElement()
• 后来,java实现了新的Collection的机制, 引入了一个崭新的和Enumeration类似的 interface: Iterator, 其有三个函数hasNext(),next(),remove()

Compose多个class在自己内部,然后自己设计函数,在函数内部使用compose的对象

• 打开功放
• 打开DVD
• 打开电视机
• …..

• 首先是Amplifier类

  package org.hfeng.misc.hfdp.ch7.facade;
  
  public class Amplifier {
      String description;
      public Amplifier(String description) {
          this.description = description;
      }
  
      public void on() {
          System.out.println("Amplifier is on");
      }
  }
  

• 然后是DvdPlayer类 (compose了Amplifer)

  package org.hfeng.misc.hfdp.ch7.facade;
  
  public class DvdPlayer {
      private String description;
      Amplifier amplifier;
  
      public DvdPlayer(String description, Amplifier amplifier) {
          this.description = description;
          this.amplifier = amplifier;
      }
  
      public void on() {
          System.out.println("DVD player is on");
      }
  }
  

• Screen类

  package org.hfeng.misc.hfdp.ch7.facade;
  
  public class Screen {
      String description;
  
      public Screen(String description) {
          this.description = description;
      }
  
      public void on() {
          System.out.println("Screen is on, enjoy the movie");
      }
  }
  

• Facade类

  package org.hfeng.misc.hfdp.ch7.facade;
  
  public class HomeTheaterFacade {
      Amplifier amplifier;
      DvdPlayer dvdPlayer;
      Screen screen;
  
      public HomeTheaterFacade(Amplifier amplifier,
                               DvdPlayer dvdPlayer,
                               Screen screen) {
          this.amplifier = amplifier;
          this.dvdPlayer = dvdPlayer;
          this.screen = screen;
      }
  
      public void oneKeyWatchMovie() {
          amplifier.on();
          dvdPlayer.on();
          screen.on();
      }
  
  }
  

• Main代码

  package org.hfeng.misc.hfdp.ch7.facade;
  
  public class MainTest {
      public static void main(String[] args) {
          Amplifier amplifier = new Amplifier("Top Amplifier");
          DvdPlayer dvdPlayer = new DvdPlayer("Top DVD Player", amplifier);
          Screen screen = new Screen("Top Screen");
  
          HomeTheaterFacade homeTheaterFacade =
                  new HomeTheaterFacade(amplifier, dvdPlayer, screen);
  
          homeTheaterFacade.watchMovie();
      }
  }
  
  ////////////////////////////////////////////////////
  // <===================OUTPUT===================> //
  // Amplifier is on                                //
  // DVD player is on                               //
  // Screen is on, enjoy the movie                  //
  ////////////////////////////////////////////////////
  

The Facade Pattern provides a unified interface to a set of interfaces
in a subsystem. Facade defines a higher-level interface that makes the
subsystem easier to use

Principle of Least Knowledge - talk only to your immediate friends

• 对于咖啡:
  1. Boil some water
  2. Brew coffee in boiling water
  3. Pour coffee in cup
  4. Add sugar and milk
• 对于茶:
  1. Boil some water
  2. Brew tea in boiling water
  3. Pour tea in cup
  4. Add lemon

• 对于咖啡:

  public class Coffee {
      void prepareRecipe() {
          boilWater();
          brewCoffeeGrinds();
          pourInCup();
          addSugarAndMilk();
      }
  
      public void boilWater() {
          System.out.println("Boling water");
      }
  
      public void brewCoffeeGrinds() {
          System.out.println("Dripping Coffee through filter");
      }
  
      public void pourInCup() {
          System.out.println("Pouring into cup");
      }
  
      public void addSugarAndMilk() {
          System.out.println("Adding Sugar and Milk");
      }
  }
  

• 对于茶

  public class Tea {
      void prepareRecipe() {
          boilWater();
          steepTeaBag();
          pourInCup();
          addLemon();
      }
  
      public void boilWater() {
          System.out.println("Boiling water");
      }
  
      public void steepTeaBag() {
          System.out.println("Steeping the tea");
      }
  
      public void addLemon() {
          System.out.println("Adding Lemon");
      }
  
      public void pourInCup() {
          System.out.println("Pouring into cup");
      }
  }
  

• brewCoffeeGrinds()和steepTeaBag()是一回事: 都是把原料准备好
• addSugarAndMilk()和addLemon()更是一回事: 都是添加调味料,只是调味料不同而已

The Template Method defines the steps of an algorithm and allows
subclasses to provoie the implementation for one or more steps

The Template Method Pattern defines the skeleton of an algorithm in a
method, deferring some steps to subclasses. Template Method lets
subclasses redefine certain steps of an algorithm without changing
the algorithm's structure.

• 如果subclass想更改一部分的Algorithm的话,可以选择override这个函数
• 如果subclass不想更改Algorithm的话,那么不用去管这个函数

The Hollywood Principle: Don't call us, we'll call you

• 首先,你不要调用我,那会产生复杂的调用依赖
• 其次,我给了你在Algorithm里面的hook(你可以选择override这个hook),所以肯定会 调用hook函数的,如果你override了这个函数,那么也就可以说,我调用了你.

• 首先是排序代码

  package org.hfeng.misc.hfdp.ch8.template.sort;
  
  import java.util.Arrays;
  
  public class MainTest {
      public static void main(String[] args) {
          Duck[] ducks = {
                  new Duck("Daffy", 8),
                  new Duck("Dewey", 1),
                  new Duck("Howard", 7),
                  new Duck("Louie", 2),
                  new Duck("Donald", 10),
                  new Duck("Huy", 2)
          };
  
          System.out.println("Before sorting:");
          display(ducks);
  
          Arrays.sort(ducks);
          System.out.println("\nAfter sorting:");
          display(ducks);
      }
  
      public static void display(Duck[] ducks) {
          for (int i = 0; i < ducks.length; i++) {
              System.out.println(ducks[i]);
          }
      }
  }
  
  ///////////////////////////////////////////////////////
  // <===================OUTPUT===================>    //
  // Before sorting:                                   //
  // Daffy weights        8                            //
  // Dewey weights        1                            //
  // Howard weights       7                            //
  // Louie weights        2                            //
  // Donald weights       10                           //
  // Huy weights      2                                //
  //                                                   //
  // After sorting:                                    //
  // Dewey weights        1                            //
  // Louie weights        2                            //
  // Huy weights      2                                //
  // Howard weights       7                            //
  // Daffy weights        8                            //
  // Donald weights       10                           //
  ///////////////////////////////////////////////////////
  

• 我们知道,如果你想要完成上面的排序, 得让Duck override compareTo.对了,这个 compareTo就是hook method

  package org.hfeng.misc.hfdp.ch8.template.sort;
  
  public class Duck implements Comparable<Duck> {
      String name;
      int weight;
  
      public Duck(String name, int weight) {
          this.name = name;
          this.weight = weight;
      }
  
      public String toString() {
          return name + " weights     \t" + weight;
      }
  
      public int compareTo(Duck otherDuck) {
          if (this.weight < otherDuck.weight) {
              return -1;
          } else if (this.weight == otherDuck.weight) {
              return 0;
          } else {
              return 1;
          }
      }
  }
  

• 首先Arrays.sort源代码如下

  public static void sort(Object[] a) {
      if (LegacyMergeSort.userRequested)
          legacyMergeSort(a);
      else
          ComparableTimSort.sort(a);
  }
  

• 然后legacyMergeSort代码如下

  private static void legacyMergeSort(Object[] a) {
      Object[] aux = a.clone();
      mergeSort(aux, a, 0, a.length, 0);
  }
  

• mergeSort的代码如下,终于看到了hook compareTo

  private static void mergeSort(Object[] src,
                                Object[] dest,
                                int low,
                                int high,
                                int off) {
      int length = high - low;
  
      // Insertion sort on smallest arrays
      if (length < INSERTIONSORT_THRESHOLD) {
          for (int i=low; i<high; i++)
              for (int j=i; j>low &&
                       ((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)
                  swap(dest, j, j-1);
          return;
      }
  
      // Recursively sort halves of dest into src
      int destLow  = low;
      int destHigh = high;
      low  += off;
      high += off;
      int mid = (low + high) >>> 1;
      mergeSort(dest, src, low, mid, -off);
      mergeSort(dest, src, mid, high, -off);
  
      // If list is already sorted, just copy from src to dest.  This is an
      // optimization that results in faster sorts for nearly ordered lists.
      if (((Comparable)src[mid-1]).compareTo(src[mid]) <= 0) {
          System.arraycopy(src, low, dest, destLow, length);
          return;
      }
  
      // Merge sorted halves (now in src) into dest
      for(int i = destLow, p = low, q = mid; i < destHigh; i++) {
          if (q >= high || p < mid && ((Comparable)src[p]).compareTo(src[q])<=0)
              dest[i] = src[p++];
          else
              dest[i] = src[q++];
      }
  }
  

• extends HttpServlet(因为是abstract class所以只能继承了).
• 然后override自己的doGet, doPost…
• 不能去override自己的service(), 因为那个是template method (所以如果service 给设计成final更好)

• KFC餐馆使用的是Array[]来存储menuitems
• MCD餐馆使用的是ArrayList来存储menuitems

• KFC的代码如下

  package org.hfeng.misc.hfdp.ch9.iterator;
  
  public class KFCMenu {
      private static final int MAX_ITEMS = 6;
      private int numberOfItems = 0;
      private MenuItem[] menuItems;
  
      public KFCMenu() {
          menuItems = new MenuItem[MAX_ITEMS];
          addItem("KA", 1.0);
          addItem("KB", 2.0);
          addItem("KC", 3.0);
      }
  
      public void addItem(String name, double price) {
          MenuItem menuItem = new MenuItem(name, price);
          menuItems[numberOfItems++] = menuItem;
      }
  }
  

• MCD的代码如下

  package org.hfeng.misc.hfdp.ch9.iterator;
  
  import java.util.ArrayList;
  
  public class MCDMenu {
      ArrayList menuItems;
  
      public MCDMenu() {
          menuItems = new ArrayList();
          addItem("MA", 1.0);
          addItem("MB", 2.0);
          addItem("MC", 3.0);
      }
  
      public void addItem(String name, double price) {
          MenuItem menuItem = new MenuItem(name, price);
          menuItems.add(menuItem);
      }
  }
  

The Iterator Pattern provides a way to access the elements of an aggregate
object sequentially without exposing its underlying representation

• 如果collection改变,那么我们的aggregate object要改变
• 如果我们遍历的方法改变, 那么我们的aggregate object也要改变.

A class should have only one reaseon to change.

+------------------+
|   <<interface>>  |
|   Collection     |
+------------------+
| add()            |
| addAll()         |
| clear()          |
| contains()       |
| equals()         |
| hashCode()       |
| isEmpty()        |
| iterator()       |
| remove()         |
| removeAll()      |
| retainAll()      |
| size()           |
| toArray()        |
|                  |
+------------------+

The Composite Pattern allows you to compose objects into tree
structures to represent part-whole hierarchies. Composite lets
clients treat individual objects and composition of objects
uniformly

• individual object
• composition of objects

• 共同的接口(使用了abstract class)

  package org.hfeng.misc.hfdp.ch9.composite.menu;
  
  public abstract class MenuComponent {
      public void add(MenuComponent menuComponent) {
          throw new UnsupportedOperationException();
      }
  
      public void remove(MenuComponent menuComponent) {
          throw new UnsupportedOperationException();
      }
  
      public MenuComponent getChild(int i) {
          throw new UnsupportedOperationException();
      }
  
      public String getName() {
          throw new UnsupportedOperationException();
      }
  
      public String getDescription() {
          throw new UnsupportedOperationException();
      }
  
      public double getPrice() {
          throw new UnsupportedOperationException();
      }
  
      public boolean isVegetarian() {
          throw new UnsupportedOperationException();
      }
  
      public void print() {
          throw new UnsupportedOperationException();
      }
  }
  

• 叶子节点MenuItem

  package org.hfeng.misc.hfdp.ch9.composite.menu;
  
  public class MenuItem extends MenuComponent {
      String name;
      String description;
      boolean vegetarian;
      double price;
  
      @Override
      public String getName() {
          return name;
      }
  
      @Override
      public String getDescription() {
          return description;
      }
  
      @Override
      public boolean isVegetarian() {
          return vegetarian;
      }
  
      @Override
      public double getPrice() {
          return price;
      }
  
      public MenuItem(String name,
                      String description,
                      boolean vegetarian,
                      double price) {
          this.name = name;
          this.description = description;
          this.vegetarian = vegetarian;
          this.price = price;
      }
  
      public void print() {
          System.out.println(" " + getName());
          if (isVegetarian()) {
              System.out.print("(v),");
          }
          System.out.println(getPrice());
          System.out.println(">>-- " + getDescription());
      }
  }
  

• composite节点Menu

  package org.hfeng.misc.hfdp.ch9.composite.menu;
  
  import java.util.ArrayList;
  import java.util.Iterator;
  
  public class Menu extends MenuComponent {
      ArrayList<MenuComponent> menuComponents = new ArrayList<MenuComponent>();
      String name;
      String description;
  
      public Menu(String name, String description) {
          this.name = name;
          this.description = description;
      }
  
      public void add(MenuComponent menuComponent) {
          menuComponents.add(menuComponent);
      }
  
      public void remove(MenuComponent menuComponent) {
          menuComponents.remove(menuComponent);
      }
  
      public MenuComponent getChild(int i) {
          return (MenuComponent)menuComponents.get(i);
      }
  
      public String getName() {
          return name;
      }
  
      public String getDescription() {
          return description;
      }
  
      public void print() {
          System.out.print("\n" + getName());
          System.out.println(", " + getDescription());
          System.out.println("-------------------------");
  
          Iterator<MenuComponent> iterator = menuComponents.iterator();
          while (iterator.hasNext()) {
              iterator.next().print();
          }
      }
  }
  

• Client代码Waitress

  package org.hfeng.misc.hfdp.ch9.composite.menu;
  
  public class Waitress {
      MenuComponent allMenus;
  
      public Waitress(MenuComponent allMenus) {
          this.allMenus = allMenus;
      }
  
      public void printMenu() {
          allMenus.print();
      }
  }
  

• 测试代码

  package org.hfeng.misc.hfdp.ch9.composite.menu;
  
  public class MainTest {
      public static void main(String[] args) {
          MenuComponent breakfastMenu = new Menu("Breakfast", "Breakfast");
          MenuComponent lunchMenu = new Menu("Lunch", "Lunch");
          MenuComponent dinnerMenu = new Menu("Dinner", "Dinner");
          MenuComponent dessertMenu = new Menu("Dessert", "Dessert menu is sub menu of Dinner");
  
          MenuComponent allMenus = new Menu("All", "All menus combined");
  
          allMenus.add(breakfastMenu);
          allMenus.add(lunchMenu);
          allMenus.add(dinnerMenu);
  
          breakfastMenu.add(new MenuItem(
                  "Pancake",
                  "scrambled eggs",
                  true,
                  2.99));
          breakfastMenu.add(new MenuItem(
                  "Regular Pancake",
                  "eggs, sausage",
                  false,
                  2.99));
          lunchMenu.add(new MenuItem(
                  "HotDo",
                  "hot dog, with cheese",
                  false,
                  3.05));
          dinnerMenu.add(new MenuItem(
                  "Burrito",
                  "A large burrito, with whole pinto beans",
                  true,
                  4.29));
          dessertMenu.add(new MenuItem(
                  "Sorbet",
                  "A scoop of raspberry and a scoop of lime",
                  true,
                  1.89));
  
          dinnerMenu.add(dessertMenu);
  
          Waitress waitress = new Waitress(allMenus);
          waitress.printMenu();
      }
  }
  

• 首先就是让MenuComponent接口有一个createIterator()函数

  public abstract class MenuComponent {
      //...
      public abstract Iterator createIterator();
  }
  

• MenuItem是没法返回一个iterator的,因为它内部没有容器

  public class MenuItem extends MenuComponent {
      // ...
      @Override
      public Iterator createIterator() {
          return new NullIterator();
      }
  }
  

• NullIterator 类的定义如下(意思是永远不会有下一个的iterator)

  package org.hfeng.misc.hfdp.ch9.composite.menuiterator;
  
  import java.util.Iterator;
  
  public class NullIterator implements Iterator<MenuComponent> {
      public MenuComponent next() {
          return null;
      }
  
      public boolean hasNext() {
          return false;
      }
  
      public void remove() {
          throw new UnsupportedOperationException();
      }
  }
  

• 和MenuItem对应的是Menu, 它也继承MenuComponent,但是它含有容器,所以它要返回 一个"真的iterator"

  public class Menu extends MenuComponent {
      ArrayList<MenuComponent> menuComponents = new ArrayList<MenuComponent>();
      String name;
      String description;
  
      public Menu(String name, String description) {
          this.name = name;
          this.description = description;
      }
  
      //...
      @Override
      public Iterator createIterator() {
          return new CompositeIterator(menuComponents.iterator());
      }
  }
  

• 返回的CompositeIterator是我们新创建的,要应付Menu里面还有Menu这种逻辑的Iterator

  package org.hfeng.misc.hfdp.ch9.composite.menuiterator;
  
  import java.util.*;
  
  public class CompositeIterator implements Iterator<MenuComponent> {
      Stack<Iterator<MenuComponent>> stack = new Stack<Iterator<MenuComponent>>();
  
      public CompositeIterator(Iterator iterator) {
          stack.push(iterator);
      }
  
      public MenuComponent next() {
          if (hasNext()) {
              Iterator<MenuComponent> iterator = stack.peek();
              MenuComponent component = (MenuComponent)iterator.next();
              if (component instanceof Menu) {
                  stack.push(component.createIterator());
              }
              return component;
          } else {
              return null;
          }
      }
  
      public boolean hasNext() {
          if (stack.empty()) {
              return false;
          } else {
              Iterator<MenuComponent> iterator = stack.peek();
              if (!iterator.hasNext()) {
                  stack.pop();
                  return hasNext();
              } else {
                  return true;
              }
          }
      }
  
      public void remove() {
          throw new UnsupportedOperationException();
      }
  }
  

• 现在我们的waitress就可以遍历容器里面的内容,然后判断是不是蔬菜,是的话,才会 打印.

  package org.hfeng.misc.hfdp.ch9.composite.menuiterator;
  
  import java.util.Iterator;
  
  public class Waitress {
      MenuComponent allMenus;
  
      public Waitress(MenuComponent allMenus) {
          this.allMenus = allMenus;
      }
  
      public void printMenu() {
          allMenus.print();
      }
  
      public void printVegetarianMenu() {
          Iterator<MenuComponent> iterator = allMenus.createIterator();
          System.out.println("\nVEGETARIAN MENU\n");
  
          while (iterator.hasNext()) {
              MenuComponent menuComponent = iterator.next();
              try {
                  if (menuComponent.isVegetarian()) {
                      menuComponent.print();
                  }
              } catch (UnsupportedOperationException e) {
                  // do nothing here, we just igore, as Menu object does throw
                  // UnsupportedOperationException when calling isVegetarian
              }
          }
      }
  }
  

• 测试代码如下

  package org.hfeng.misc.hfdp.ch9.composite.menuiterator;
  
  public class MainTest {
      public static void main(String[] args) {
          MenuComponent breakfastMenu = new Menu("Breakfast", "Breakfast");
          MenuComponent lunchMenu = new Menu("Lunch", "Lunch");
          MenuComponent dinnerMenu = new Menu("Dinner", "Dinner");
          MenuComponent dessertMenu = new Menu("Dessert", "Dessert menu is sub menu of Dinner");
  
          MenuComponent allMenus = new Menu("All", "All menus combined");
  
          allMenus.add(breakfastMenu);
          allMenus.add(lunchMenu);
          allMenus.add(dinnerMenu);
  
          breakfastMenu.add(new MenuItem(
                  "Pancake",
                  "scrambled eggs",
                  true,
                  2.99));
          breakfastMenu.add(new MenuItem(
                  "Regular Pancake",
                  "eggs, sausage",
                  false,
                  2.99));
          lunchMenu.add(new MenuItem(
                  "HotDo",
                  "hot dog, with cheese",
                  false,
                  3.05));
          dinnerMenu.add(new MenuItem(
                  "Burrito",
                  "A large burrito, with whole pinto beans",
                  true,
                  4.29));
          dessertMenu.add(new MenuItem(
                  "Sorbet",
                  "A scoop of raspberry and a scoop of lime",
                  true,
                  1.89));
  
          dinnerMenu.add(dessertMenu);
  
          Waitress waitress = new Waitress(allMenus);
          waitress.printVegetarianMenu();
      }
  }
  
  ////////////////////////////////////////////////////
  // <===================OUTPUT===================> //
  // VEGETARIAN MENU                                //
  //                                                //
  //  Pancake                                       //
  // (v),2.99                                       //
  // >>-- scrambled eggs                            //
  //  Burrito                                       //
  // (v),4.29                                       //
  // >>-- A large burrito, with whole pinto beans   //
  //  Sorbet                                        //
  // (v),1.89                                       //
  // >>-- A scoop of raspberry and a scoop of lime  //
  //  Sorbet                                        //
  // (v),1.89                                       //
  // >>-- A scoop of raspberry and a scoop of lime  //
  ////////////////////////////////////////////////////