iterator = aggregate.createIterator();
- while (iterator.hasNext()) {
- System.out.println(iterator.next());
- }
- }
-}
-```
-
-### JDK
-
-- [java.util.Iterator](http://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html)
-- [java.util.Enumeration](http://docs.oracle.com/javase/8/docs/api/java/util/Enumeration.html)
-
-## 5. 中介者（Mediator）
-
-### Intent
-
-集中相关对象之间复杂的沟通和控制方式。
-
-### Class Diagram
-
-- Mediator：中介者，定义一个接口用于与各同事（Colleague）对象通信。
-- Colleague：同事，相关对象
-
- 
-
-### Implementation
-
-Alarm（闹钟）、CoffeePot（咖啡壶）、Calendar（日历）、Sprinkler（喷头）是一组相关的对象，在某个对象的事件产生时需要去操作其它对象，形成了下面这种依赖结构：
-
- 
-
-使用中介者模式可以将复杂的依赖结构变成星形结构：
-
- 
-
-```java
-public abstract class Colleague {
- public abstract void onEvent(Mediator mediator);
-}
-```
-
-```java
-public class Alarm extends Colleague {
-
- @Override
- public void onEvent(Mediator mediator) {
- mediator.doEvent("alarm");
- }
-
- public void doAlarm() {
- System.out.println("doAlarm()");
- }
-}
-```
-
-```java
-public class CoffeePot extends Colleague {
- @Override
- public void onEvent(Mediator mediator) {
- mediator.doEvent("coffeePot");
- }
-
- public void doCoffeePot() {
- System.out.println("doCoffeePot()");
- }
-}
-```
-
-```java
-public class Calender extends Colleague {
- @Override
- public void onEvent(Mediator mediator) {
- mediator.doEvent("calender");
- }
-
- public void doCalender() {
- System.out.println("doCalender()");
- }
-}
-```
-
-```java
-public class Sprinkler extends Colleague {
- @Override
- public void onEvent(Mediator mediator) {
- mediator.doEvent("sprinkler");
- }
-
- public void doSprinkler() {
- System.out.println("doSprinkler()");
- }
-}
-```
-
-```java
-public abstract class Mediator {
- public abstract void doEvent(String eventType);
-}
-```
-
-```java
-public class ConcreteMediator extends Mediator {
- private Alarm alarm;
- private CoffeePot coffeePot;
- private Calender calender;
- private Sprinkler sprinkler;
-
- public ConcreteMediator(Alarm alarm, CoffeePot coffeePot, Calender calender, Sprinkler sprinkler) {
- this.alarm = alarm;
- this.coffeePot = coffeePot;
- this.calender = calender;
- this.sprinkler = sprinkler;
- }
-
- @Override
- public void doEvent(String eventType) {
- switch (eventType) {
- case "alarm":
- doAlarmEvent();
- break;
- case "coffeePot":
- doCoffeePotEvent();
- break;
- case "calender":
- doCalenderEvent();
- break;
- default:
- doSprinklerEvent();
- }
- }
-
- public void doAlarmEvent() {
- alarm.doAlarm();
- coffeePot.doCoffeePot();
- calender.doCalender();
- sprinkler.doSprinkler();
- }
-
- public void doCoffeePotEvent() {
- // ...
- }
-
- public void doCalenderEvent() {
- // ...
- }
-
- public void doSprinklerEvent() {
- // ...
- }
-}
-```
-
-```java
-public class Client {
- public static void main(String[] args) {
- Alarm alarm = new Alarm();
- CoffeePot coffeePot = new CoffeePot();
- Calender calender = new Calender();
- Sprinkler sprinkler = new Sprinkler();
- Mediator mediator = new ConcreteMediator(alarm, coffeePot, calender, sprinkler);
- // 闹钟事件到达，调用中介者就可以操作相关对象
- alarm.onEvent(mediator);
- }
-}
-```
-
-```java
-doAlarm()
-doCoffeePot()
-doCalender()
-doSprinkler()
-```
-
-### JDK
-
-- All scheduleXXX() methods of [java.util.Timer](http://docs.oracle.com/javase/8/docs/api/java/util/Timer.html)
-- [java.util.concurrent.Executor#execute()](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Executor.html#execute-java.lang.Runnable-)
-- submit() and invokeXXX() methods of [java.util.concurrent.ExecutorService](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html)
-- scheduleXXX() methods of [java.util.concurrent.ScheduledExecutorService](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ScheduledExecutorService.html)
-- [java.lang.reflect.Method#invoke()](http://docs.oracle.com/javase/8/docs/api/java/lang/reflect/Method.html#invoke-java.lang.Object-java.lang.Object...-)
-
-## 6. 备忘录（Memento）
-
-### Intent
-
-在不违反封装的情况下获得对象的内部状态，从而在需要时可以将对象恢复到最初状态。
-
-### Class Diagram
-
-- Originator：原始对象
-- Caretaker：负责保存好备忘录
-- Menento：备忘录，存储原始对象的的状态。备忘录实际上有两个接口，一个是提供给 Caretaker 的窄接口：它只能将备忘录传递给其它对象；一个是提供给 Originator 的宽接口，允许它访问到先前状态所需的所有数据。理想情况是只允许 Originator 访问本备忘录的内部状态。
-
- 
-
-### Implementation
-
-以下实现了一个简单计算器程序，可以输入两个值，然后计算这两个值的和。备忘录模式允许将这两个值存储起来，然后在某个时刻用存储的状态进行恢复。
-
-实现参考：[Memento Pattern - Calculator Example - Java Sourcecode](https://www.oodesign.com/memento-pattern-calculator-example-java-sourcecode.html)
-
-```java
-/**
- * Originator Interface
- */
-public interface Calculator {
-
- // Create Memento
- PreviousCalculationToCareTaker backupLastCalculation();
-
- // setMemento
- void restorePreviousCalculation(PreviousCalculationToCareTaker memento);
-
- int getCalculationResult();
-
- void setFirstNumber(int firstNumber);
-
- void setSecondNumber(int secondNumber);
-}
-```
-
-```java
-/**
- * Originator Implementation
- */
-public class CalculatorImp implements Calculator {
-
- private int firstNumber;
- private int secondNumber;
-
- @Override
- public PreviousCalculationToCareTaker backupLastCalculation() {
- // create a memento object used for restoring two numbers
- return new PreviousCalculationImp(firstNumber, secondNumber);
- }
-
- @Override
- public void restorePreviousCalculation(PreviousCalculationToCareTaker memento) {
- this.firstNumber = ((PreviousCalculationToOriginator) memento).getFirstNumber();
- this.secondNumber = ((PreviousCalculationToOriginator) memento).getSecondNumber();
- }
-
- @Override
- public int getCalculationResult() {
- // result is adding two numbers
- return firstNumber + secondNumber;
- }
-
- @Override
- public void setFirstNumber(int firstNumber) {
- this.firstNumber = firstNumber;
- }
-
- @Override
- public void setSecondNumber(int secondNumber) {
- this.secondNumber = secondNumber;
- }
-}
-```
-
-```java
-/**
- * Memento Interface to Originator
- *
- * This interface allows the originator to restore its state
- */
-public interface PreviousCalculationToOriginator {
- int getFirstNumber();
- int getSecondNumber();
-}
-```
-
-```java
-/**
- * Memento interface to CalculatorOperator (Caretaker)
- */
-public interface PreviousCalculationToCareTaker {
- // no operations permitted for the caretaker
-}
-```
-
-```java
-/**
- * Memento Object Implementation
- *
- * Note that this object implements both interfaces to Originator and CareTaker
- */
-public class PreviousCalculationImp implements PreviousCalculationToCareTaker,
- PreviousCalculationToOriginator {
-
- private int firstNumber;
- private int secondNumber;
-
- public PreviousCalculationImp(int firstNumber, int secondNumber) {
- this.firstNumber = firstNumber;
- this.secondNumber = secondNumber;
- }
-
- @Override
- public int getFirstNumber() {
- return firstNumber;
- }
-
- @Override
- public int getSecondNumber() {
- return secondNumber;
- }
-}
-```
-
-```java
-/**
- * CareTaker object
- */
-public class Client {
-
- public static void main(String[] args) {
- // program starts
- Calculator calculator = new CalculatorImp();
-
- // assume user enters two numbers
- calculator.setFirstNumber(10);
- calculator.setSecondNumber(100);
-
- // find result
- System.out.println(calculator.getCalculationResult());
-
- // Store result of this calculation in case of error
- PreviousCalculationToCareTaker memento = calculator.backupLastCalculation();
-
- // user enters a number
- calculator.setFirstNumber(17);
-
- // user enters a wrong second number and calculates result
- calculator.setSecondNumber(-290);
-
- // calculate result
- System.out.println(calculator.getCalculationResult());
-
- // user hits CTRL + Z to undo last operation and see last result
- calculator.restorePreviousCalculation(memento);
-
- // result restored
- System.out.println(calculator.getCalculationResult());
- }
-}
-```
-
-```html
-110
--273
-110
-```
-
-### JDK
-
-- java.io.Serializable
-
-## 7. 观察者（Observer）
-
-### Intent
-
-定义对象之间的一对多依赖，当一个对象状态改变时，它的所有依赖都会收到通知并且自动更新状态。
-
-主题（Subject）是被观察的对象，而其所有依赖者（Observer）称为观察者。
-
-
-
-### Class Diagram
-
-主题（Subject）具有注册和移除观察者、并通知所有观察者的功能，主题是通过维护一张观察者列表来实现这些操作的。
-
-观察者（Observer）的注册功能需要调用主题的 registerObserver() 方法。
-
- 
-
-### Implementation
-
-天气数据布告板会在天气信息发生改变时更新其内容，布告板有多个，并且在将来会继续增加。
-
- 
-
-```java
-public interface Subject {
- void registerObserver(Observer o);
-
- void removeObserver(Observer o);
-
- void notifyObserver();
-}
-```
-
-```java
-public class WeatherData implements Subject {
- private List observers;
- private float temperature;
- private float humidity;
- private float pressure;
-
- public WeatherData() {
- observers = new ArrayList<>();
- }
-
- public void setMeasurements(float temperature, float humidity, float pressure) {
- this.temperature = temperature;
- this.humidity = humidity;
- this.pressure = pressure;
- notifyObserver();
- }
-
- @Override
- public void registerObserver(Observer o) {
- observers.add(o);
- }
-
- @Override
- public void removeObserver(Observer o) {
- int i = observers.indexOf(o);
- if (i >= 0) {
- observers.remove(i);
- }
- }
-
- @Override
- public void notifyObserver() {
- for (Observer o : observers) {
- o.update(temperature, humidity, pressure);
- }
- }
-}
-```
-
-```java
-public interface Observer {
- void update(float temp, float humidity, float pressure);
-}
-```
-
-```java
-public class StatisticsDisplay implements Observer {
-
- public StatisticsDisplay(Subject weatherData) {
- weatherData.reisterObserver(this);
- }
-
- @Override
- public void update(float temp, float humidity, float pressure) {
- System.out.println("StatisticsDisplay.update: " + temp + " " + humidity + " " + pressure);
- }
-}
-```
-
-```java
-public class CurrentConditionsDisplay implements Observer {
-
- public CurrentConditionsDisplay(Subject weatherData) {
- weatherData.registerObserver(this);
- }
-
- @Override
- public void update(float temp, float humidity, float pressure) {
- System.out.println("CurrentConditionsDisplay.update: " + temp + " " + humidity + " " + pressure);
- }
-}
-```
-
-```java
-public class WeatherStation {
- public static void main(String[] args) {
- WeatherData weatherData = new WeatherData();
- CurrentConditionsDisplay currentConditionsDisplay = new CurrentConditionsDisplay(weatherData);
- StatisticsDisplay statisticsDisplay = new StatisticsDisplay(weatherData);
-
- weatherData.setMeasurements(0, 0, 0);
- weatherData.setMeasurements(1, 1, 1);
- }
-}
-```
-
-```html
-CurrentConditionsDisplay.update: 0.0 0.0 0.0
-StatisticsDisplay.update: 0.0 0.0 0.0
-CurrentConditionsDisplay.update: 1.0 1.0 1.0
-StatisticsDisplay.update: 1.0 1.0 1.0
-```
-
-### JDK
-
-- [java.util.Observer](http://docs.oracle.com/javase/8/docs/api/java/util/Observer.html)
-- [java.util.EventListener](http://docs.oracle.com/javase/8/docs/api/java/util/EventListener.html)
-- [javax.servlet.http.HttpSessionBindingListener](http://docs.oracle.com/javaee/7/api/javax/servlet/http/HttpSessionBindingListener.html)
-- [RxJava](https://github.com/ReactiveX/RxJava)
-
-## 8. 状态（State）
-
-### Intent
-
-允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它所属的类。
-
-### Class Diagram
-
- 
-
-### Implementation
-
-糖果销售机有多种状态，每种状态下销售机有不同的行为，状态可以发生转移，使得销售机的行为也发生改变。
-
- 
-
-```java
-public interface State {
- /**
- * 投入 25 分钱
- */
- void insertQuarter();
-
- /**
- * 退回 25 分钱
- */
- void ejectQuarter();
-
- /**
- * 转动曲柄
- */
- void turnCrank();
-
- /**
- * 发放糖果
- */
- void dispense();
-}
-```
-
-```java
-public class HasQuarterState implements State {
-
- private GumballMachine gumballMachine;
-
- public HasQuarterState(GumballMachine gumballMachine) {
- this.gumballMachine = gumballMachine;
- }
-
- @Override
- public void insertQuarter() {
- System.out.println("You can't insert another quarter");
- }
-
- @Override
- public void ejectQuarter() {
- System.out.println("Quarter returned");
- gumballMachine.setState(gumballMachine.getNoQuarterState());
- }
-
- @Override
- public void turnCrank() {
- System.out.println("You turned...");
- gumballMachine.setState(gumballMachine.getSoldState());
- }
-
- @Override
- public void dispense() {
- System.out.println("No gumball dispensed");
- }
-}
-```
-
-```java
-public class NoQuarterState implements State {
-
- GumballMachine gumballMachine;
-
- public NoQuarterState(GumballMachine gumballMachine) {
- this.gumballMachine = gumballMachine;
- }
-
- @Override
- public void insertQuarter() {
- System.out.println("You insert a quarter");
- gumballMachine.setState(gumballMachine.getHasQuarterState());
- }
-
- @Override
- public void ejectQuarter() {
- System.out.println("You haven't insert a quarter");
- }
-
- @Override
- public void turnCrank() {
- System.out.println("You turned, but there's no quarter");
- }
-
- @Override
- public void dispense() {
- System.out.println("You need to pay first");
- }
-}
-```
-
-```java
-public class SoldOutState implements State {
-
- GumballMachine gumballMachine;
-
- public SoldOutState(GumballMachine gumballMachine) {
- this.gumballMachine = gumballMachine;
- }
-
- @Override
- public void insertQuarter() {
- System.out.println("You can't insert a quarter, the machine is sold out");
- }
-
- @Override
- public void ejectQuarter() {
- System.out.println("You can't eject, you haven't inserted a quarter yet");
- }
-
- @Override
- public void turnCrank() {
- System.out.println("You turned, but there are no gumballs");
- }
-
- @Override
- public void dispense() {
- System.out.println("No gumball dispensed");
- }
-}
-```
-
-```java
-public class SoldState implements State {
-
- GumballMachine gumballMachine;
-
- public SoldState(GumballMachine gumballMachine) {
- this.gumballMachine = gumballMachine;
- }
-
- @Override
- public void insertQuarter() {
- System.out.println("Please wait, we're already giving you a gumball");
- }
-
- @Override
- public void ejectQuarter() {
- System.out.println("Sorry, you already turned the crank");
- }
-
- @Override
- public void turnCrank() {
- System.out.println("Turning twice doesn't get you another gumball!");
- }
-
- @Override
- public void dispense() {
- gumballMachine.releaseBall();
- if (gumballMachine.getCount() > 0) {
- gumballMachine.setState(gumballMachine.getNoQuarterState());
- } else {
- System.out.println("Oops, out of gumballs");
- gumballMachine.setState(gumballMachine.getSoldOutState());
- }
- }
-}
-```
-
-```java
-public class GumballMachine {
-
- private State soldOutState;
- private State noQuarterState;
- private State hasQuarterState;
- private State soldState;
-
- private State state;
- private int count = 0;
-
- public GumballMachine(int numberGumballs) {
- count = numberGumballs;
- soldOutState = new SoldOutState(this);
- noQuarterState = new NoQuarterState(this);
- hasQuarterState = new HasQuarterState(this);
- soldState = new SoldState(this);
-
- 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();
- }
-
- public void setState(State state) {
- this.state = state;
- }
-
- public void releaseBall() {
- System.out.println("A gumball comes rolling out the slot...");
- if (count != 0) {
- count -= 1;
- }
- }
-
- public State getSoldOutState() {
- return soldOutState;
- }
-
- public State getNoQuarterState() {
- return noQuarterState;
- }
-
- public State getHasQuarterState() {
- return hasQuarterState;
- }
-
- public State getSoldState() {
- return soldState;
- }
-
- public int getCount() {
- return count;
- }
-}
-```
-
-```java
-public class Client {
-
- public static void main(String[] args) {
- GumballMachine gumballMachine = new GumballMachine(5);
-
- gumballMachine.insertQuarter();
- gumballMachine.turnCrank();
-
- gumballMachine.insertQuarter();
- gumballMachine.ejectQuarter();
- gumballMachine.turnCrank();
-
- gumballMachine.insertQuarter();
- gumballMachine.turnCrank();
- gumballMachine.insertQuarter();
- gumballMachine.turnCrank();
- gumballMachine.ejectQuarter();
-
- gumballMachine.insertQuarter();
- gumballMachine.insertQuarter();
- gumballMachine.turnCrank();
- gumballMachine.insertQuarter();
- gumballMachine.turnCrank();
- gumballMachine.insertQuarter();
- gumballMachine.turnCrank();
- }
-}
-```
-
-```html
-You insert a quarter
-You turned...
-A gumball comes rolling out the slot...
-You insert a quarter
-Quarter returned
-You turned, but there's no quarter
-You need to pay first
-You insert a quarter
-You turned...
-A gumball comes rolling out the slot...
-You insert a quarter
-You turned...
-A gumball comes rolling out the slot...
-You haven't insert a quarter
-You insert a quarter
-You can't insert another quarter
-You turned...
-A gumball comes rolling out the slot...
-You insert a quarter
-You turned...
-A gumball comes rolling out the slot...
-Oops, out of gumballs
-You can't insert a quarter, the machine is sold out
-You turned, but there are no gumballs
-No gumball dispensed
-```
-
-## 9. 策略（Strategy）
-
-### Intent
-
-定义一系列算法，封装每个算法，并使它们可以互换。
-
-策略模式可以让算法独立于使用它的客户端。
-
-### Class Diagram
-
-- Strategy 接口定义了一个算法族，它们都实现了 behavior() 方法。
-- Context 是使用到该算法族的类，其中的 doSomething() 方法会调用 behavior()，setStrategy(Strategy) 方法可以动态地改变 strategy 对象，也就是说能动态地改变 Context 所使用的算法。
-
- 
-
-### 与状态模式的比较
-
-状态模式的类图和策略模式类似，并且都是能够动态改变对象的行为。但是状态模式是通过状态转移来改变 Context 所组合的 State 对象，而策略模式是通过 Context 本身的决策来改变组合的 Strategy 对象。所谓的状态转移，是指 Context 在运行过程中由于一些条件发生改变而使得 State 对象发生改变，注意必须要是在运行过程中。
-
-状态模式主要是用来解决状态转移的问题，当状态发生转移了，那么 Context 对象就会改变它的行为；而策略模式主要是用来封装一组可以互相替代的算法族，并且可以根据需要动态地去替换 Context 使用的算法。
-
-### Implementation
-
-设计一个鸭子，它可以动态地改变叫声。这里的算法族是鸭子的叫声行为。
-
-```java
-public interface QuackBehavior {
- void quack();
-}
-```
-
-```java
-public class Quack implements QuackBehavior {
- @Override
- public void quack() {
- System.out.println("quack!");
- }
-}
-```
-
-```java
-public class Squeak implements QuackBehavior{
- @Override
- public void quack() {
- System.out.println("squeak!");
- }
-}
-```
-
-```java
-public class Duck {
-
- private QuackBehavior quackBehavior;
-
- public void performQuack() {
- if (quackBehavior != null) {
- quackBehavior.quack();
- }
- }
-
- public void setQuackBehavior(QuackBehavior quackBehavior) {
- this.quackBehavior = quackBehavior;
- }
-}
-```
-
-```java
-public class Client {
-
- public static void main(String[] args) {
- Duck duck = new Duck();
- duck.setQuackBehavior(new Squeak());
- duck.performQuack();
- duck.setQuackBehavior(new Quack());
- duck.performQuack();
- }
-}
-```
-
-```html
-squeak!
-quack!
-```
-
-### JDK
-
-- java.util.Comparator#compare()
-- javax.servlet.http.HttpServlet
-- javax.servlet.Filter#doFilter()
-
-## 10. 模板方法（Template Method）
-
-### Intent
-
-定义算法框架，并将一些步骤的实现延迟到子类。
-
-通过模板方法，子类可以重新定义算法的某些步骤，而不用改变算法的结构。
-
-### Class Diagram
-
- 
-
-### Implementation
-
-冲咖啡和冲茶都有类似的流程，但是某些步骤会有点不一样，要求复用那些相同步骤的代码。
-
- 
-
-```java
-public abstract class CaffeineBeverage {
-
- final void prepareRecipe() {
- boilWater();
- brew();
- pourInCup();
- addCondiments();
- }
-
- abstract void brew();
-
- abstract void addCondiments();
-
- void boilWater() {
- System.out.println("boilWater");
- }
-
- void pourInCup() {
- System.out.println("pourInCup");
- }
-}
-```
-
-```java
-public class Coffee extends CaffeineBeverage {
- @Override
- void brew() {
- System.out.println("Coffee.brew");
- }
-
- @Override
- void addCondiments() {
- System.out.println("Coffee.addCondiments");
- }
-}
-```
-
-```java
-public class Tea extends CaffeineBeverage {
- @Override
- void brew() {
- System.out.println("Tea.brew");
- }
-
- @Override
- void addCondiments() {
- System.out.println("Tea.addCondiments");
- }
-}
-```
-
-```java
-public class Client {
- public static void main(String[] args) {
- CaffeineBeverage caffeineBeverage = new Coffee();
- caffeineBeverage.prepareRecipe();
- System.out.println("-----------");
- caffeineBeverage = new Tea();
- caffeineBeverage.prepareRecipe();
- }
-}
-```
-
-```html
-boilWater
-Coffee.brew
-pourInCup
-Coffee.addCondiments
------------
-boilWater
-Tea.brew
-pourInCup
-Tea.addCondiments
-```
-
-### JDK
-
-- java.util.Collections#sort()
-- java.io.InputStream#skip()
-- java.io.InputStream#read()
-- java.util.AbstractList#indexOf()
-
-## 11. 访问者（Visitor）
-
-### Intent
-
-为一个对象结构（比如组合结构）增加新能力。
-
-### Class Diagram
-
-- Visitor：访问者，为每一个 ConcreteElement 声明一个 visit 操作
-- ConcreteVisitor：具体访问者，存储遍历过程中的累计结果
-- ObjectStructure：对象结构，可以是组合结构，或者是一个集合。
-
- 
-
-### Implementation
-
-```java
-public interface Element {
- void accept(Visitor visitor);
-}
-```
-
-```java
-class CustomerGroup {
-
- private List customers = new ArrayList<>();
-
- void accept(Visitor visitor) {
- for (Customer customer : customers) {
- customer.accept(visitor);
- }
- }
-
- void addCustomer(Customer customer) {
- customers.add(customer);
- }
-}
-```
-
-```java
-public class Customer implements Element {
-
- private String name;
- private List orders = new ArrayList<>();
-
- Customer(String name) {
- this.name = name;
- }
-
- String getName() {
- return name;
- }
-
- void addOrder(Order order) {
- orders.add(order);
- }
-
- public void accept(Visitor visitor) {
- visitor.visit(this);
- for (Order order : orders) {
- order.accept(visitor);
- }
- }
-}
-```
-
-```java
-public class Order implements Element {
-
- private String name;
- private List- items = new ArrayList();
-
- Order(String name) {
- this.name = name;
- }
-
- Order(String name, String itemName) {
- this.name = name;
- this.addItem(new Item(itemName));
- }
-
- String getName() {
- return name;
- }
-
- void addItem(Item item) {
- items.add(item);
- }
-
- public void accept(Visitor visitor) {
- visitor.visit(this);
-
- for (Item item : items) {
- item.accept(visitor);
- }
- }
-}
-```
-
-```java
-public class Item implements Element {
-
- private String name;
-
- Item(String name) {
- this.name = name;
- }
-
- String getName() {
- return name;
- }
-
- public void accept(Visitor visitor) {
- visitor.visit(this);
- }
-}
-```
-
-```java
-public interface Visitor {
- void visit(Customer customer);
-
- void visit(Order order);
-
- void visit(Item item);
-}
-```
-
-```java
-public class GeneralReport implements Visitor {
-
- private int customersNo;
- private int ordersNo;
- private int itemsNo;
-
- public void visit(Customer customer) {
- System.out.println(customer.getName());
- customersNo++;
- }
-
- public void visit(Order order) {
- System.out.println(order.getName());
- ordersNo++;
- }
-
- public void visit(Item item) {
- System.out.println(item.getName());
- itemsNo++;
- }
-
- public void displayResults() {
- System.out.println("Number of customers: " + customersNo);
- System.out.println("Number of orders: " + ordersNo);
- System.out.println("Number of items: " + itemsNo);
- }
-}
-```
-
-```java
-public class Client {
- public static void main(String[] args) {
- Customer customer1 = new Customer("customer1");
- customer1.addOrder(new Order("order1", "item1"));
- customer1.addOrder(new Order("order2", "item1"));
- customer1.addOrder(new Order("order3", "item1"));
-
- Order order = new Order("order_a");
- order.addItem(new Item("item_a1"));
- order.addItem(new Item("item_a2"));
- order.addItem(new Item("item_a3"));
- Customer customer2 = new Customer("customer2");
- customer2.addOrder(order);
-
- CustomerGroup customers = new CustomerGroup();
- customers.addCustomer(customer1);
- customers.addCustomer(customer2);
-
- GeneralReport visitor = new GeneralReport();
- customers.accept(visitor);
- visitor.displayResults();
- }
-}
-```
-
-```html
-customer1
-order1
-item1
-order2
-item1
-order3
-item1
-customer2
-order_a
-item_a1
-item_a2
-item_a3
-Number of customers: 2
-Number of orders: 4
-Number of items: 6
-```
-
-### JDK
-
-- javax.lang.model.element.Element and javax.lang.model.element.ElementVisitor
-- javax.lang.model.type.TypeMirror and javax.lang.model.type.TypeVisitor
-
-## 12. 空对象（Null）
-
-### Intent
-
-使用什么都不做的空对象来代替 NULL。
-
-一个方法返回 NULL，意味着方法的调用端需要去检查返回值是否是 NULL，这么做会导致非常多的冗余的检查代码。并且如果某一个调用端忘记了做这个检查返回值，而直接使用返回的对象，那么就有可能抛出空指针异常。
-
-### Class Diagram
-
-
-
-### Implementation
-
-```java
-public abstract class AbstractOperation {
- abstract void request();
-}
-```
-
-```java
-public class RealOperation extends AbstractOperation {
- @Override
- void request() {
- System.out.println("do something");
- }
-}
-```
-
-```java
-public class NullOperation extends AbstractOperation{
- @Override
- void request() {
- // do nothing
- }
-}
-```
-
-```java
-public class Client {
- public static void main(String[] args) {
- AbstractOperation abstractOperation = func(-1);
- abstractOperation.request();
- }
-
- public static AbstractOperation func(int para) {
- if (para < 0) {
- return new NullOperation();
- }
- return new RealOperation();
- }
-}
-```
-
-# 四、结构型
-
-## 1. 适配器（Adapter）
-
-### Intent
-
-把一个类接口转换成另一个用户需要的接口。
-
- 
-
-### Class Diagram
-
- 
-
-### Implementation
-
-鸭子（Duck）和火鸡（Turkey）拥有不同的叫声，Duck 的叫声调用 quack() 方法，而 Turkey 调用 gobble() 方法。
-
-要求将 Turkey 的 gobble() 方法适配成 Duck 的 quack() 方法，从而让火鸡冒充鸭子！
-
-```java
-public interface Duck {
- void quack();
-}
-```
-
-```java
-public interface Turkey {
- void gobble();
-}
-```
-
-```java
-public class WildTurkey implements Turkey {
- @Override
- public void gobble() {
- System.out.println("gobble!");
- }
-}
-```
-
-```java
-public class TurkeyAdapter implements Duck {
- Turkey turkey;
-
- public TurkeyAdapter(Turkey turkey) {
- this.turkey = turkey;
- }
-
- @Override
- public void quack() {
- turkey.gobble();
- }
-}
-```
-
-```java
-public class Client {
- public static void main(String[] args) {
- Turkey turkey = new WildTurkey();
- Duck duck = new TurkeyAdapter(turkey);
- duck.quack();
- }
-}
-```
-
-### JDK
-
-- [java.util.Arrays#asList()](http://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html#asList%28T...%29)
-- [java.util.Collections#list()](https://docs.oracle.com/javase/8/docs/api/java/util/Collections.html#list-java.util.Enumeration-)
-- [java.util.Collections#enumeration()](https://docs.oracle.com/javase/8/docs/api/java/util/Collections.html#enumeration-java.util.Collection-)
-- [javax.xml.bind.annotation.adapters.XMLAdapter](http://docs.oracle.com/javase/8/docs/api/javax/xml/bind/annotation/adapters/XmlAdapter.html#marshal-BoundType-)
-
-## 2. 桥接（Bridge）
-
-### Intent
-
-将抽象与实现分离开来，使它们可以独立变化。
-
-### Class Diagram
-
-- Abstraction：定义抽象类的接口
-- Implementor：定义实现类接口
-
- 
-
-### Implementation
-
-RemoteControl 表示遥控器，指代 Abstraction。
-
-TV 表示电视，指代 Implementor。
-
-桥接模式将遥控器和电视分离开来，从而可以独立改变遥控器或者电视的实现。
-
-```java
-public abstract class TV {
- public abstract void on();
-
- public abstract void off();
-
- public abstract void tuneChannel();
-}
-```
-
-```java
-public class Sony extends TV {
- @Override
- public void on() {
- System.out.println("Sony.on()");
- }
-
- @Override
- public void off() {
- System.out.println("Sony.off()");
- }
-
- @Override
- public void tuneChannel() {
- System.out.println("Sony.tuneChannel()");
- }
-}
-```
-
-```java
-public class RCA extends TV {
- @Override
- public void on() {
- System.out.println("RCA.on()");
- }
-
- @Override
- public void off() {
- System.out.println("RCA.off()");
- }
-
- @Override
- public void tuneChannel() {
- System.out.println("RCA.tuneChannel()");
- }
-}
-```
-
-```java
-public abstract class RemoteControl {
- protected TV tv;
-
- public RemoteControl(TV tv) {
- this.tv = tv;
- }
-
- public abstract void on();
-
- public abstract void off();
-
- public abstract void tuneChannel();
-}
-```
-
-```java
-public class ConcreteRemoteControl1 extends RemoteControl {
- public ConcreteRemoteControl1(TV tv) {
- super(tv);
- }
-
- @Override
- public void on() {
- System.out.println("ConcreteRemoteControl1.on()");
- tv.on();
- }
-
- @Override
- public void off() {
- System.out.println("ConcreteRemoteControl1.off()");
- tv.off();
- }
-
- @Override
- public void tuneChannel() {
- System.out.println("ConcreteRemoteControl1.tuneChannel()");
- tv.tuneChannel();
- }
-}
-```
-
-```java
-public class ConcreteRemoteControl2 extends RemoteControl {
- public ConcreteRemoteControl2(TV tv) {
- super(tv);
- }
-
- @Override
- public void on() {
- System.out.println("ConcreteRemoteControl2.on()");
- tv.on();
- }
-
- @Override
- public void off() {
- System.out.println("ConcreteRemoteControl2.off()");
- tv.off();
- }
-
- @Override
- public void tuneChannel() {
- System.out.println("ConcreteRemoteControl2.tuneChannel()");
- tv.tuneChannel();
- }
-}
-```
-
-```java
-public class Client {
- public static void main(String[] args) {
- RemoteControl remoteControl1 = new ConcreteRemoteControl1(new RCA());
- remoteControl1.on();
- remoteControl1.off();
- remoteControl1.tuneChannel();
- RemoteControl remoteControl2 = new ConcreteRemoteControl2(new Sony());
- remoteControl2.on();
- remoteControl2.off();
- remoteControl2.tuneChannel();
- }
-}
-```
-
-### JDK
-
-- AWT (It provides an abstraction layer which maps onto the native OS the windowing support.)
-- JDBC
-
-## 3. 组合（Composite）
-
-### Intent
-
-将对象组合成树形结构来表示“整体/部分”层次关系，允许用户以相同的方式处理单独对象和组合对象。
-
-### Class Diagram
-
-组件（Component）类是组合类（Composite）和叶子类（Leaf）的父类，可以把组合类看成是树的中间节点。
-
-组合对象拥有一个或者多个组件对象，因此组合对象的操作可以委托给组件对象去处理，而组件对象可以是另一个组合对象或者叶子对象。
-
- 
-
-### Implementation
-
-```java
-public abstract class Component {
- protected String name;
-
- public Component(String name) {
- this.name = name;
- }
-
- public void print() {
- print(0);
- }
-
- abstract void print(int level);
-
- abstract public void add(Component component);
-
- abstract public void remove(Component component);
-}
-```
-
-```java
-public class Composite extends Component {
-
- private List child;
-
- public Composite(String name) {
- super(name);
- child = new ArrayList<>();
- }
-
- @Override
- void print(int level) {
- for (int i = 0; i < level; i++) {
- System.out.print("--");
- }
- System.out.println("Composite:" + name);
- for (Component component : child) {
- component.print(level + 1);
- }
- }
-
- @Override
- public void add(Component component) {
- child.add(component);
- }
-
- @Override
- public void remove(Component component) {
- child.remove(component);
- }
-}
-```
-
-```java
-public class Leaf extends Component {
- public Leaf(String name) {
- super(name);
- }
-
- @Override
- void print(int level) {
- for (int i = 0; i < level; i++) {
- System.out.print("--");
- }
- System.out.println("left:" + name);
- }
-
- @Override
- public void add(Component component) {
- throw new UnsupportedOperationException(); // 牺牲透明性换取单一职责原则，这样就不用考虑是叶子节点还是组合节点
- }
-
- @Override
- public void remove(Component component) {
- throw new UnsupportedOperationException();
- }
-}
-```
-
-```java
-public class Client {
- public static void main(String[] args) {
- Composite root = new Composite("root");
- Component node1 = new Leaf("1");
- Component node2 = new Composite("2");
- Component node3 = new Leaf("3");
- root.add(node1);
- root.add(node2);
- root.add(node3);
- Component node21 = new Leaf("21");
- Component node22 = new Composite("22");
- node2.add(node21);
- node2.add(node22);
- Component node221 = new Leaf("221");
- node22.add(node221);
- root.print();
- }
-}
-```
-
-```html
-Composite:root
---left:1
---Composite:2
-----left:21
-----Composite:22
-------left:221
---left:3
-```
-
-### JDK
-
-- javax.swing.JComponent#add(Component)
-- java.awt.Container#add(Component)
-- java.util.Map#putAll(Map)
-- java.util.List#addAll(Collection)
-- java.util.Set#addAll(Collection)
-
-## 4. 装饰（Decorator）
-
-### Intent
-
-为对象动态添加功能。
-
-### Class Diagram
-
-装饰者（Decorator）和具体组件（ConcreteComponent）都继承自组件（Component），具体组件的方法实现不需要依赖于其它对象，而装饰者组合了一个组件，这样它可以装饰其它装饰者或者具体组件。所谓装饰，就是把这个装饰者套在被装饰者之上，从而动态扩展被装饰者的功能。装饰者的方法有一部分是自己的，这属于它的功能，然后调用被装饰者的方法实现，从而也保留了被装饰者的功能。可以看到，具体组件应当是装饰层次的最低层，因为只有具体组件的方法实现不需要依赖于其它对象。
-
- 
-
-### Implementation
-
-设计不同种类的饮料，饮料可以添加配料，比如可以添加牛奶，并且支持动态添加新配料。每增加一种配料，该饮料的价格就会增加，要求计算一种饮料的价格。
-
-下图表示在 DarkRoast 饮料上新增新添加 Mocha 配料，之后又添加了 Whip 配料。DarkRoast 被 Mocha 包裹，Mocha 又被 Whip 包裹。它们都继承自相同父类，都有 cost() 方法，外层类的 cost() 方法调用了内层类的 cost() 方法。
-
- 
-
-```java
-public interface Beverage {
- double cost();
-}
-```
-
-```java
-public class DarkRoast implements Beverage {
- @Override
- public double cost() {
- return 1;
- }
-}
-```
-
-```java
-public class HouseBlend implements Beverage {
- @Override
- public double cost() {
- return 1;
- }
-}
-```
-
-```java
-public abstract class CondimentDecorator implements Beverage {
- protected Beverage beverage;
-}
-```
-
-```java
-public class Milk extends CondimentDecorator {
-
- public Milk(Beverage beverage) {
- this.beverage = beverage;
- }
-
- @Override
- public double cost() {
- return 1 + beverage.cost();
- }
-}
-```
-
-```java
-public class Mocha extends CondimentDecorator {
-
- public Mocha(Beverage beverage) {
- this.beverage = beverage;
- }
-
- @Override
- public double cost() {
- return 1 + beverage.cost();
- }
-}
-```
-
-```java
-public class Client {
-
- public static void main(String[] args) {
- Beverage beverage = new HouseBlend();
- beverage = new Mocha(beverage);
- beverage = new Milk(beverage);
- System.out.println(beverage.cost());
- }
-}
-```
-
-```html
-3.0
-```
-
-### 设计原则
-
-类应该对扩展开放，对修改关闭：也就是添加新功能时不需要修改代码。饮料可以动态添加新的配料，而不需要去修改饮料的代码。
-
-不可能把所有的类设计成都满足这一原则，应当把该原则应用于最有可能发生改变的地方。
-
-### JDK
-
-- java.io.BufferedInputStream(InputStream)
-- java.io.DataInputStream(InputStream)
-- java.io.BufferedOutputStream(OutputStream)
-- java.util.zip.ZipOutputStream(OutputStream)
-- java.util.Collections#checked[List|Map|Set|SortedSet|SortedMap]()
-
-## 5. 外观（Facade）
-
-### Intent
-
-提供了一个统一的接口，用来访问子系统中的一群接口，从而让子系统更容易使用。
-
-### Class Diagram
-
- 
-
-### Implementation
-
-观看电影需要操作很多电器，使用外观模式实现一键看电影功能。
-
-```java
-public class SubSystem {
- public void turnOnTV() {
- System.out.println("turnOnTV()");
- }
-
- public void setCD(String cd) {
- System.out.println("setCD( " + cd + " )");
- }
-
- public void startWatching(){
- System.out.println("startWatching()");
- }
-}
-```
-
-```java
-public class Facade {
- private SubSystem subSystem = new SubSystem();
-
- public void watchMovie() {
- subSystem.turnOnTV();
- subSystem.setCD("a movie");
- subSystem.startWatching();
- }
-}
-```
-
-```java
-public class Client {
- public static void main(String[] args) {
- Facade facade = new Facade();
- facade.watchMovie();
- }
-}
-```
-
-### 设计原则
-
-最少知识原则：只和你的密友谈话。也就是说客户对象所需要交互的对象应当尽可能少。
-
-## 6. 享元（Flyweight）
-
-### Intent
-
-利用共享的方式来支持大量细粒度的对象，这些对象一部分内部状态是相同的。
-
-### Class Diagram
-
-- Flyweight：享元对象
-- IntrinsicState：内部状态，享元对象共享内部状态
-- ExtrinsicState：外部状态，每个享元对象的外部状态不同
-
- 
-
-### Implementation
-
-```java
-public interface Flyweight {
- void doOperation(String extrinsicState);
-}
-```
-
-```java
-public class ConcreteFlyweight implements Flyweight {
-
- private String intrinsicState;
-
- public ConcreteFlyweight(String intrinsicState) {
- this.intrinsicState = intrinsicState;
- }
-
- @Override
- public void doOperation(String extrinsicState) {
- System.out.println("Object address: " + System.identityHashCode(this));
- System.out.println("IntrinsicState: " + intrinsicState);
- System.out.println("ExtrinsicState: " + extrinsicState);
- }
-}
-```
-
-```java
-public class FlyweightFactory {
-
- private HashMap flyweights = new HashMap<>();
-
- Flyweight getFlyweight(String intrinsicState) {
- if (!flyweights.containsKey(intrinsicState)) {
- Flyweight flyweight = new ConcreteFlyweight(intrinsicState);
- flyweights.put(intrinsicState, flyweight);
- }
- return flyweights.get(intrinsicState);
- }
-}
-```
-
-```java
-public class Client {
-
- public static void main(String[] args) {
- FlyweightFactory factory = new FlyweightFactory();
- Flyweight flyweight1 = factory.getFlyweight("aa");
- Flyweight flyweight2 = factory.getFlyweight("aa");
- flyweight1.doOperation("x");
- flyweight2.doOperation("y");
- }
-}
-```
-
-```html
-Object address: 1163157884
-IntrinsicState: aa
-ExtrinsicState: x
-Object address: 1163157884
-IntrinsicState: aa
-ExtrinsicState: y
-```
-
-### JDK
-
-Java 利用缓存来加速大量小对象的访问时间。
-
-- java.lang.Integer#valueOf(int)
-- java.lang.Boolean#valueOf(boolean)
-- java.lang.Byte#valueOf(byte)
-- java.lang.Character#valueOf(char)
-
-## 7. 代理（Proxy）
-
-### Intent
-
-控制对其它对象的访问。
-
-### Class Diagram
-
-代理有以下四类：
-
-- 远程代理（Remote Proxy）：控制对远程对象（不同地址空间）的访问，它负责将请求及其参数进行编码，并向不同地址空间中的对象发送已经编码的请求。
-- 虚拟代理（Virtual Proxy）：根据需要创建开销很大的对象，它可以缓存实体的附加信息，以便延迟对它的访问，例如在网站加载一个很大图片时，不能马上完成，可以用虚拟代理缓存图片的大小信息，然后生成一张临时图片代替原始图片。
-- 保护代理（Protection Proxy）：按权限控制对象的访问，它负责检查调用者是否具有实现一个请求所必须的访问权限。
-- 智能代理（Smart Reference）：取代了简单的指针，它在访问对象时执行一些附加操作：记录对象的引用次数；当第一次引用一个对象时，将它装入内存；在访问一个实际对象前，检查是否已经锁定了它，以确保其它对象不能改变它。
-
-
-
-### Implementation
-
-以下是一个虚拟代理的实现，模拟了图片延迟加载的情况下使用与图片大小相等的临时内容去替换原始图片，直到图片加载完成才将图片显示出来。
-
-```java
-public interface Image {
- void showImage();
-}
-```
-
-```java
-public class HighResolutionImage implements Image {
-
- private URL imageURL;
- private long startTime;
- private int height;
- private int width;
-
- public int getHeight() {
- return height;
- }
-
- public int getWidth() {
- return width;
- }
-
- public HighResolutionImage(URL imageURL) {
- this.imageURL = imageURL;
- this.startTime = System.currentTimeMillis();
- this.width = 600;
- this.height = 600;
- }
-
- public boolean isLoad() {
- // 模拟图片加载，延迟 3s 加载完成
- long endTime = System.currentTimeMillis();
- return endTime - startTime > 3000;
- }
-
- @Override
- public void showImage() {
- System.out.println("Real Image: " + imageURL);
- }
-}
-```
-
-```java
-public class ImageProxy implements Image {
-
- private HighResolutionImage highResolutionImage;
-
- public ImageProxy(HighResolutionImage highResolutionImage) {
- this.highResolutionImage = highResolutionImage;
- }
-
- @Override
- public void showImage() {
- while (!highResolutionImage.isLoad()) {
- try {
- System.out.println("Temp Image: " + highResolutionImage.getWidth() + " " + highResolutionImage.getHeight());
- Thread.sleep(100);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
- highResolutionImage.showImage();
- }
-}
-```
-
-```java
-public class ImageViewer {
-
- public static void main(String[] args) throws Exception {
- String image = "http://image.jpg";
- URL url = new URL(image);
- HighResolutionImage highResolutionImage = new HighResolutionImage(url);
- ImageProxy imageProxy = new ImageProxy(highResolutionImage);
- imageProxy.showImage();
- }
-}
-```
-
-### JDK
-
-- java.lang.reflect.Proxy
-- RMI
-
-# 参考资料
-
-- 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
-- Gamma E. 设计模式: 可复用面向对象软件的基础 [M]. 机械工业出版社, 2007.
-- Bloch J. Effective java[M]. Addison-Wesley Professional, 2017.
-- [Design Patterns](http://www.oodesign.com/)
-- [Design patterns implemented in Java](http://java-design-patterns.com/)
-- [The breakdown of design patterns in JDK](http://www.programering.com/a/MTNxAzMwATY.html)
+本文是各设计模式笔记的合并版，内容已经落后于单独的笔记，请从 [设计模式目录](设计模式%20-%20目录.md) 阅读。
