设计模式

2020-07-20

设计原则

找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。即把会变化的部分取出并封装起来，以便以后可以轻易地改动或扩充此部分，而不影响不需要变化的其他部分。
针对接口编程，而不是针对实现编程。
多用组合，少用继承。
为了交互对象之间的松耦合设计而努力。
开放-关闭原则：类应该对扩展开放，对修改关闭。（装饰者模式）
依赖倒置原则：要依赖抽象，不要依赖具体类。（工厂方法模式）
最少知识原则（德墨忒尔法则 Law of Demeter）：最少知识原则，只和你密友对话。
好莱坞原则：别调用（打电话给）我们，我们会调用（打电话给）你。高层组件对底层组件的方式是“别调用我们，我们会调用你。”，无绝对，例如底层组件在结束时，常常会调用从超类中继承来的方法。我们要做的是避免让高层和底层组件之间有明显的环状依赖，进行解耦。
单一责任原则：一个类应该只有一个引起变化的原因。—— 类的每个责任都有改变的潜在区域。超过一个责任，意味着超过一个改变的区域。

内聚(cohesion) 度量一个类或模块紧密地达到单一目的或责任。当一个模块或一个类被设计成只支持一组相关的功能时，我们说它具有高内聚；反之，当被设计成支持一组不想关的功能时，我们说它具有低内聚。
方针：

该对象本身
被当做方法的参数而传递进来的对象
此方法所创建或实例化的任何对象
对象的任何组件

策略模式

定义：策略模式定义了算法簇，分别封装起来，让它们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。

鸭子实例

（1）鸭子有不同的种类，有的鸭子不会飞，有的鸭子叫声不同，显然继承的方法很笨拙，牵一发而动全身。例如fly方法如果用继承显然不合适；
（2）如果将fly和quack抽离出来，形成两种接口，不同的鸭子实现这个接口就更灵活了！但是，问题在于接口的实现会导致代码重复！例如两种不同的鸭子实现了同一种的飞行或鸣叫的行为，显然这是不合适的！代码重复啊！
（3）应用原则 找出可能需要变化的部分独立出来并封装，这里变化的是fly和quack行为，再应用原则 针对借口变编程，而不是针对实现编程，将行为抽象为接口，每一种行为封装成 行为类，这样同一种行为用一个类就行表示！避免（2）的代码重复，最后运用组合将行为设计成Duck类的变量，就可以做到同一个鸭子类切换不同行为类的目的，即动态设置行为，更为灵活！

注意；针对接口编程，这里的“接口”是一个概念，可解释针对超类型编程，通常是一个抽象类或者一个接口，利用多态在执行时根据实际类型执行真正的行为！

package StrategyPattern;

//鸭子超类
abstract class Duck {
    FlyBehavior flyBehavior;  //飞行行为接口对象
    QuackBehavior quackBehavior; //每只鸭子都会引用实现QuackBehavior接口的对象

    public Duck() {
    }

    public void performQuack() {  //鸭子对象不亲自处理呱呱叫行为，而是委托给quackBehavior引用的对象
        quackBehavior.quack();
    }

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

    public void swim() {
        System.out.println("All ducks float, even decoys!");
    }

    //动态设置鸭子行为，而不是在子类中构造函数初始化定死
    public void setFlyBehavior(FlyBehavior fb) {
        flyBehavior = fb;
    }

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

    public abstract void display();
}


//行为接口与类实现
interface FlyBehavior {
    public void fly();
}

interface QuackBehavior {
    public void quack();
}
//飞行行为类
class FlyWithWings implements FlyBehavior {  //会飞的鸭子用
    public void fly() {
        System.out.println("I'm flying!");
    }
}

class FlyNoWay implements FlyBehavior {  //不会飞的鸭子用
    public void fly() {
        System.out.println("I can't fly!");
    }
}
//鸭子叫行为类
class Quack implements QuackBehavior {  //呱呱叫
    public void quack() {
        System.out.println("Quack");
    }
}

class MuteQuack implements QuackBehavior { //鸭子不会叫
    public void quack() {
        System.out.println("<< Silence >>");
    }
}

class Squeak implements QuackBehavior { //鸭子叫另一种声音
    public void quack() {
        System.out.println("Squeak");
    }
}
//其他行为类
class FLyRocketPowered implements FlyBehavior{ //火箭动力行为
    public void fly(){
        System.out.println("I'm flying with a rocket!");
    }
}

//MallarDuck鸭子子类实现
class MallarDuck extends Duck {
    public MallarDuck() {
        quackBehavior = new Quack();
        flyBehavior = new FlyWithWings();
    }

    public void display() {
        System.out.println("I'm a real Mallard duck.");
    }
}
//模型鸭
class ModelDuck extends Duck{
    public ModelDuck(){
        flyBehavior = new FlyNoWay();
        quackBehavior = new Quack();
    }
    public void display(){
        System.out.println("I'm a model duck!");
    }
}
public class MiniDuckSimulator {
    public static void main(String[] args) {
        Duck mallard = new MallarDuck();
        mallard.performQuack();
        mallard.performFly();

        Duck model = new MallarDuck();
        model.performFly();
        model.setFlyBehavior(new FLyRocketPowered());
        model.performFly();
    }
}

游戏人物实例UML

游戏角色的类和角色可以使用的武器行为的类，每个角色一次只能使用一种武器，但是可以在游戏的过程中换武器。

观察者模式

定义：观察者模式定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。
出版者+订阅者=观察者模式
订阅者可订阅或取消订阅，出版者需要推送或者根据用户需求进行推送。

报纸订阅实例

设计气象站

（1）WeatherData从气象站获得数据，而后将信息推送给三个布告板；
（2）WeatherData需要setter和getter进行设置/获取数据；
（3）系统必须可扩展，即可以让其他开发人员建立定制的布告板，用户可以随心所欲地添加或删除任何布告板，所以WeatherData需要注册、移除、以及通知布告板（即关注了WeatherData的布告板们）。
（4）错误示范：

此图中三个具体的布告板针对具体实现编程，而非针对接口！
对于每个新的布告板，我们都得修改WeatherData代码！
无法在运行时动态地增加或删除布告板！
尚未封装改变的部分，即不同布告板可能增加、删除
（5）再来看正确的UML图：
主题Subject设计为接口，因为观察者可以订阅不同的主题，而不同主题有共同相似的方法
观察者需要更新数据，以及根据需求进行展示数据（有些不需要展示数据），所以设计成两个接口Observer和DisplayElement
通过组合，即Observer的数组（这里使用的是超类型，方便多态和新的观察者的扩展）动态管理观察者，主题的代码不需要修改！
以此可以独立地复用主题或观察者，因为二者并非紧耦合！符合为了交互对象之间的松耦合设计而努力的原则。
缺点：主题盲推，不管订阅者的需求，订阅者可能只需要一部分更新而非全部，没有提供公开的getter方法让观察者实现自主的消息更新。——具体解决方法参见后面的Java.util.obversable的实现。

package ObserverPattern;

import java.util.ArrayList;

interface Subject {
    void registerObserver(Observer o);

    void removeObserver(Observer o);

    void notifyObservers();
}

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

interface DisplayElement {
    void display();
}

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

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

    @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 notifyObservers() {
        for (Observer observer : observers) {
            observer.update(temperature, humidity, pressure);
        }
    }

    public void measurementsChanged() { //从气象站得到更新观测值时，通知观察者
        notifyObservers();
    }

    public void setMeasurements(float temperature, float humidity, float pressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        this.pressure = pressure;
        measurementsChanged();
    }

}

class CurrentConditionsDisplay implements Observer, DisplayElement {
    private float temperature;
    private float humidity;
    private Subject weatherData;

    public CurrentConditionsDisplay(Subject weatherData) {
        this.weatherData = weatherData;
        this.weatherData.registerObserver(this); //注册自身观察者
    }

    @Override
    public void update(float temp, float humidity, float pressure) {
        this.temperature = temp;
        this.humidity = humidity;
        display();
    }

    @Override
    public void display() {
        System.out.println("Current conditions: " + temperature + "F degrees and " + humidity + "% humidity");
    }
}


class StatisticsDisplay implements Observer, DisplayElement{
    private float maxTemp = 0.0f;
    private float minTemp = 200;
    private float tempSum = 0.0f;
    private int numReadings;
    private WeatherData weatherData;
    public StatisticsDisplay(WeatherData weatherData){
        this.weatherData = weatherData;
        this.weatherData.registerObserver(this);
    }

    @Override
    public void update(float temp, float humidity, float pressure) {
        tempSum = temp;
        maxTemp = Math.max(maxTemp, temp);
        minTemp = Math.min(minTemp, temp);
        display();
    }

    @Override
    public void display() {
        System.out.println("Avg/Max/Min temprature = " + (tempSum / numReadings)
        + "/" + maxTemp + "/" + minTemp);
    }
}

class ForecastDisplay implements Observer, DisplayElement{
    private float currentPressure = 29.92f;
    private float lastPressure;
    private WeatherData weatherData;
    public ForecastDisplay(WeatherData weatherData){
        this.weatherData = weatherData;
        this.weatherData.registerObserver(this);
    }

    @Override
    public void update(float temp, float humidity, float pressure) {
        lastPressure = currentPressure;
        currentPressure = pressure;
        display();
    }

    @Override
    public void display() {
        System.out.print("Forecast: ");
        if(currentPressure > lastPressure){
            System.out.println("Improving weather on the way!");
        }else if(currentPressure == lastPressure){
            System.out.println("More of the same");
        }else{
            System.out.println("Watch out for cooler, rainy weather");
        }
    }
}

class HeatIndexDisplay implements Observer, DisplayElement{
    private float heatIndex = 0.0f;
    private WeatherData weatherData;
    public HeatIndexDisplay(WeatherData weatherData){
        this.weatherData = weatherData;
        this.weatherData.registerObserver(this);
    }

    @Override
    public void update(float temp, float humidity, float pressure) {
        heatIndex = computeHeatIndex(temp ,humidity);
        display();
    }

    private float computeHeatIndex(float t, float rh){
        float index = (float)((16.923 + (0.185212 * t) + (5.37941 * rh) - (0.100254 * t * rh)
                + (0.00941695 * (t * t)) + (0.00728898 * (rh * rh))
                + (0.000345372 * (t * t * rh)) - (0.000814971 * (t * rh * rh)) +
                (0.0000102102 * (t * t * rh * rh)) - (0.000038646 * (t * t * t)) + (0.0000291583 *
                (rh * rh * rh)) + (0.00000142721 * (t * t * t * rh)) +
                (0.000000197483 * (t * rh * rh * rh)) - (0.0000000218429 * (t * t * t * rh * rh)) +
                0.000000000843296 * (t * t * rh * rh * rh)) -
                (0.0000000000481975 * (t * t * t * rh * rh * rh)));
        return index;
    }

    @Override
    public void display() {
        System.out.println("Heat index is " + heatIndex);
    }
}
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);
        HeatIndexDisplay heatIndexDisplay = new HeatIndexDisplay(weatherData);

        weatherData.setMeasurements(80, 65, 30.4f);
        weatherData.setMeasurements(82, 70, 29.2f);
        weatherData.setMeasurements(78, 90, 29.2f);
    }
}

使用Java.util.Observable以及Observer实现

（1）注意Observable是一个类而非接口，且其中的setChanged()方法为protected，所以只有继承才能实现对应功能，限制了其复用和灵活性，违反了多用组合，少用继承的原则；
（2）不过，其update(Observable o, Object arg)的第一个参数可以根据观察者依赖的Subject进行更新，如果不是其依赖的Subject则无法更新，且更新数据可以通过该参数调用Observable的getter获得属性，而不用Subject全推信息！而arg方法则避免了方法参数的冗长，通过对象封装数据，更具拓展性。
（3）针对其缺点，可以从头实现接口式的观察者模式。

package ObserverPattern_Observable;
import java.util.Observable;
import java.util.Observer;

interface DisplayElement{
    void display();
}
class WeatherData extends Observable{
    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();
    }
    public float getTemperature(){
        return temperature;
    }
    public float getHumidity(){
        return humidity;
    }
    public float getPressure(){
        return pressure;
    }
}

class CurrentConditionsDisplay implements Observer, DisplayElement{
    private Observable observable;
    private float temperature;
    private float humidity;
    public CurrentConditionsDisplay(Observable observable){
        this.observable = observable;
        this.observable.addObserver(this);
    }

    @Override
    public void update(Observable o, Object arg) { //Subjcets只有是WeatherData才能更新此Observer
        if(o instanceof WeatherData){
            WeatherData weatherData = (WeatherData) o;
            this.temperature = weatherData.getTemperature();
            this.humidity = weatherData.getHumidity();
            display();
        }
    }

    @Override
    public void display() {
        System.out.println("Current conditions: " + temperature
            + "F degrees and " + humidity + "% humidity");
    }
}

class ForecastDisplay implements Observer, DisplayElement{
    private float currentPressure = 29.92f;
    private float lastPressure;
    public ForecastDisplay(Observable observable){
        observable.addObserver(this);
    }

    @Override
    public void update(Observable o, Object arg) {
        if(o instanceof WeatherData){
            WeatherData weatherData = (WeatherData) o;
            lastPressure = currentPressure;
            currentPressure = weatherData.getPressure();
            display();
        }
    }

    @Override
    public void display() {
        System.out.print("Forecase: ");
        System.out.print("Forecast: ");
        if (currentPressure > lastPressure) {
            System.out.println("Improving weather on the way!");
        } else if (currentPressure == lastPressure) {
            System.out.println("More of the same");
        } else if (currentPressure < lastPressure) {
            System.out.println("Watch out for cooler, rainy weather");
        }
    }
}

class StatisticsDisplay implements Observer, DisplayElement{
    private float maxTemp = 0.0f;
    private float minTemp = 200;
    private float tempSum = 0.0f;
    private int numReadings;

    public StatisticsDisplay(Observable observable){
        observable.addObserver(this);
    }

    @Override
    public void update(Observable o, Object arg) {
        if(o instanceof WeatherData){
            WeatherData weatherData = (WeatherData) o;
            float temp = weatherData.getTemperature();
            tempSum += temp;
            numReadings++;

            maxTemp = Math.max(maxTemp, temp);
            minTemp = Math.min(minTemp, temp);

            display();
        }
    }

    @Override
    public void display() {
        System.out.println("Avg/Max/Min temperature = " + (tempSum / numReadings)
                + "/" + maxTemp + "/" + minTemp);
    }
}

class HeatIndexDisplay implements Observer, DisplayElement{
    float heatIndex = 0.0f;

    public HeatIndexDisplay(Observable observable){
        observable.addObserver(this);
    }

    @Override
    public void update(Observable o, Object arg) {
        if (o instanceof WeatherData) {
            WeatherData weatherData = (WeatherData) o;
            float t = weatherData.getTemperature();
            float rh = weatherData.getHumidity();
            heatIndex = (float)
                    (
                            (16.923 + (0.185212 * t)) +
                                    (5.37941 * rh) -
                                    (0.100254 * t * rh) +
                                    (0.00941695 * (t * t)) +
                                    (0.00728898 * (rh * rh)) +
                                    (0.000345372 * (t * t * rh)) -
                                    (0.000814971 * (t * rh * rh)) +
                                    (0.0000102102 * (t * t * rh * rh)) -
                                    (0.000038646 * (t * t * t)) +
                                    (0.0000291583 * (rh * rh * rh)) +
                                    (0.00000142721 * (t * t * t * rh)) +
                                    (0.000000197483 * (t * rh * rh * rh)) -
                                    (0.0000000218429 * (t * t * t * rh * rh)) +
                                    (0.000000000843296 * (t * t * rh * rh * rh)) -
                                    (0.0000000000481975 * (t * t * t * rh * rh * rh)));
            display();
        }
    }

    @Override
    public void display() {
        System.out.println("Heat index is " + heatIndex);
    }
}
public class WeatherStationObservable {
    public static void main(String[] args){
        WeatherData weatherData = new WeatherData();

        CurrentConditionsDisplay currentConditions = new CurrentConditionsDisplay(weatherData);
        StatisticsDisplay statisticsDisplay = new StatisticsDisplay(weatherData);
        ForecastDisplay forecastDisplay = new ForecastDisplay(weatherData);

        weatherData.setMeasurements(80, 65, 30.4f);
        weatherData.setMeasurements(82, 70, 29.2f);
        weatherData.setMeasurements(78, 90, 29.2f);
    }
}

JDK中观察者模式

Swing API:JButtion的超类AbstractButtion，会看到许多增加与删除倾听者listener的方法，这些方法可以让观察者感应到Swing组件的不同类型事件。

装饰者模式

定义：装饰者模式动态地将责任附加到对象上，若要扩展功能，装饰者提供了比继承更有弹性的替代方案。

辛巴克咖啡实例

（1）不同顾客需求不同，需要在基础的咖啡上加不同的辅料，不可能对枚举所有情况然后每个都设计为一个类；
（2）如果饮料基类包含不同辅料的设置和判断方法是否可行？扩展性差！每当有新的辅料加入或者辅料删除都得修改基类代码，而继承带来的缺点牵一发而动全身，也不可取；
（3）运用开放-关闭原则，对扩展开放，对修改关闭，做到咖啡基类与辅料适度解耦，底料咖啡，用不同辅料装饰。基类为咖啡，装饰基类继承基类，因为包装后的东西肯定还是咖啡，所以通过咖啡基类和装饰基类可以扩展不同的具体的咖啡子类和辅料子类，最后计算价格。
（4）思考：如果通过组合来实现呢？比如装饰基类改成辅料基类而不继承自饮料基类，饮料基类中通过组合维护一个辅料基类的数组，只需要追加添加辅料的方法即可，但是如果饮料分为不同大小，这个如何设计？辅料需要知道饮料的大小进行辅料的计算，不同辅料计算方式肯定不同，肯定需要将饮料大小传入辅料类，这样做会很麻烦，很不方便。

package DecoratorPattern;

//饮料抽象类
abstract class Beverage{
    String description = "Unknown Beverage";
    public String getDescription(){
        return description;
    }
    public abstract double cost();
}

//调料抽象类
abstract class CondimentDecorator extends Beverage{
    Beverage beverage;
    public abstract String getDescription();
}

//饮料类
class Espresso extends Beverage{
    public Espresso(){
        description = "Espresso";
    }
    public double cost(){
        return 1.99;
    }
}

class HouseBlend extends Beverage{
    public HouseBlend(){
        description = "House Blend Coffee";
    }
    public double cost(){
        return 0.89;
    }
}

class DarkRoast extends Beverage{
    public DarkRoast(){
        description = "Dark Roast Coffee";
    }
    public double cost(){
        return 0.99;
    }
}

class Decaf extends Beverage{
    public Decaf(){
        description = "Decaf Coffee";
    }
    public double cost(){
        return 1.05;
    }
}

//调料类
class Mocha extends CondimentDecorator{
    public Mocha(Beverage beverage){
        this.beverage = beverage;
    }
    public String getDescription(){
        return beverage.getDescription() + "Mocha";
    }
    public double cost(){
        return 0.20 + beverage.cost();
    }
}

class Soy extends CondimentDecorator{
    public Soy(Beverage beverage){
        this.beverage = beverage;
    }
    public String getDescription(){
        return beverage.getDescription() + "Soy";
    }
    public double cost(){
        return 0.15 + beverage.cost();
    }
}

class Whip extends CondimentDecorator{
    public Whip(Beverage beverage){
        this.beverage = beverage;
    }
    public String getDescription(){
        return beverage.getDescription() + "Whip";
    }
    public double cost(){
        return 0.10 + beverage.cost();
    }
}

class Milk extends CondimentDecorator{
    public Milk(Beverage beverage){
        this.beverage = beverage;
    }
    public String getDescription(){
        return beverage.getDescription() + "Milk";
    }
    public double cost(){
        return 0.10 + beverage.cost();
    }
}
public class StarbuzzCoffee {
    public static void main(String[] args){
        Beverage beverage = new Espresso();
        System.out.println(beverage.getDescription()
        + " $" + beverage.cost());

        Beverage beverage1 = new DarkRoast();
        beverage1 = new Mocha(beverage1); // 加调料
        beverage1 = new Mocha(beverage1);
        beverage1 = new Whip(beverage1);
        System.out.println(beverage1.getDescription()
        + " $" + beverage1.cost());

        Beverage beverage2 = new HouseBlend();
        beverage2 = new Soy(beverage2); //加调料
        beverage2 = new Mocha(beverage2);
        beverage2 = new Whip(beverage2);
        System.out.println(beverage2.getDescription()
        + " $" + beverage2.cost());
    }
}

装饰Java.io类

package DecoratorPattern.io;

import java.io.*;

class LowerCaseInputStream extends FilterInputStream {
    public LowerCaseInputStream(InputStream in) {
        super(in);
    }

    @Override
    public int read() throws IOException {
        int c = in.read();
        return (c == -1 ? c : Character.toLowerCase((char) c));
    }

    @Override
    public int read(byte[] b, int off, int len) throws IOException {
        int result = in.read(b, off, len);
        for(int i=off;i<off+result;i++){
            b[i] = (byte)Character.toLowerCase((char)b[i]);
        }
        return result;
    }
}

public class InputTest {
    public static void main(String[] args) throws IOException{
        int c;
        System.out.println(System.getProperty("user.dir"));
        InputStream in = null;
        try{
            in = new LowerCaseInputStream(
                    new BufferedInputStream(
                            new FileInputStream("src/resources/test.txt")));
            while((c = in.read()) >= 0){
                System.out.print((char) c);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if(in != null) in.close();
        }

        System.out.println();
        try(InputStream in2 = new LowerCaseInputStream(
                new BufferedInputStream(
                        new FileInputStream("src/resources/test.txt")))){
            while((c = in2.read()) >= 0){
                System.out.print((char) c);
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

星巴克咖啡带Size版本

package DecoratorPattern.StarbuzzCoffeeWithSize;


//饮料抽象类
abstract class Beverage {
    public enum Size {TALL, GRANDE, VENTI}

    ; //小中大杯
    Size size = Size.TALL;
    String description = "Unknown Beverage";

    public String getDescription() {
        return description;
    }

    public void setSize(Size size) {
        this.size = size;
    }

    public Size getSize() {
        return this.size;
    }

    public abstract double cost();
}

//调料抽象类
abstract class CondimentDecorator extends Beverage {
    public Beverage beverage;

    public abstract String getDescription();

    public Size getSize() {
        return beverage.getSize();
    }
}

//饮料类
class DarkRoast extends Beverage {
    public DarkRoast() {
        description = "Dark Roast";
    }
    public double cost(){return 0.99;}
}

class Decaf extends Beverage{
    public Decaf(){
        description = "Decaf Coffee";
    }
    public double cost(){
        return 1.05;
    }
}

class Espresso extends Beverage{
    public Espresso(){
        description = "Espresso";
    }
    public double cost(){
        return 1.99;
    }
}

class HouseBlend extends Beverage{
    public HouseBlend(){
        description = "House Blend";
    }

    @Override
    public double cost() {
        return 0.89;
    }
}

//调料类
class Milk extends CondimentDecorator{
    public Milk(Beverage beverage){
        this.beverage = beverage;
    }
    @Override
    public String getDescription(){
        return beverage.getDescription() + ", Milk";
    }

    @Override
    public double cost() {
        return beverage.cost() + 0.10;
    }
}

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

    @Override
    public String getDescription() {
        return beverage.getDescription() + ", Mocha";
    }

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

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

    @Override
    public String getDescription() {
        return beverage.getDescription() + ", Soy";
    }

    @Override
    public double cost() {
        double cost = beverage.cost();
        if(beverage.getSize() == Size.TALL){
            cost += 0.10;
        }else if(beverage.getSize() == Size.GRANDE){
            cost += 0.15;
        }else if(beverage.getSize() == Size.VENTI){
            cost += 0.20;
        }
        return cost;
    }
}

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

    @Override
    public String getDescription() {
        return beverage.getDescription() + ", Whip";
    }

    @Override
    public double cost() {
        return beverage.cost() + 0.10;
    }
}
public class StarbuzzCoffeeWithSize {
    public static void main(String[] args){
        Beverage beverage = new Espresso();
        System.out.println(beverage.getDescription()
        + " $" + String.format("%.2f", beverage.cost()));

        Beverage beverage1 = new DarkRoast();
        beverage1 = new Mocha(beverage1);
        beverage1 = new Mocha(beverage1);
        beverage1 = new Whip(beverage1);
        System.out.println(beverage1.getDescription()
        + " $" + String.format("%.2f", beverage1.cost()));

        Beverage beverage2 = new HouseBlend();
        beverage2.setSize(Beverage.Size.VENTI);
        beverage2 = new Soy(beverage2);
        beverage2 = new Mocha(beverage2);
        beverage2 = new Whip(beverage2);
        System.out.println(beverage2.getDescription()
        + " $" + String.format("%.2f", beverage2.cost()));
    }
}

工厂模式

工厂方法模式

工厂方法模式定义：工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。
所有工厂模式都用来封装对象的创建。工厂模式（Factory Method Pattern）通过让子类决定该创建的对象是什么，来达到将对象创建的过程封装的目的。

继承

抽象工厂模式

抽象工厂模式定义：抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

对象的组合

Pizaa简单工厂实例

（1）披萨的制作流程一致，包含固定的几种原料，例如面团、芝士、蔬菜等
（2）但具体的披萨子类用料不同，披萨商店需要更具订单选择生产哪种披萨，应用原则将变化的部分独立出来进行封装将实例化披萨类的代码独立出来用简单工厂进行实例化，这样做的目的不必修改商店类，只需修改简单工厂类即可。

package FactoryPattern.PizzaStore_Simple_Factory;

import java.util.ArrayList;

//Pizza抽象类
abstract class Pizza{
    String name;
    String dough;
    String sauce;
    ArrayList<String> toppings = new ArrayList<>();

    public String getName(){return name;}
    public void prepare(){
        System.out.println("Preparing " + name);
    }
    public void bake(){
        System.out.println("Baking " + name);
    }
    public void cut(){
        System.out.println("Cutting " + name);
    }
    public void box(){
        System.out.println("Boxing " + name);
    }
    public String toString(){
        StringBuffer display = new StringBuffer();
        display.append("---- " + name + " ----\n");
        display.append(dough + "\n");
        display.append(sauce + "\n");
        for(String topping:toppings){
            display.append(topping + "\n");
        }
        return display.toString();
    }
}

//Pizza类
class CheesePizza extends Pizza{
    public CheesePizza(){
        name = " Cheese Pizza";
        dough = "Regular Crust";
        sauce = "Marinara Pizza Sauce";
        toppings.add("Fresh Mozzarella");
        toppings.add("Parmesan");
    }
}

class ClamPizza extends Pizza{
    public ClamPizza(){
        name = "Clam Pizza";
        dough = "Thin crust";
        sauce = "White garlic sauce";
        toppings.add("Clams");
        toppings.add("Grated parmesan cheese");
    }
}

class PepperoniPizza extends Pizza{
    public PepperoniPizza(){
        name = "Pepperoni Pizza";
        dough = "Crust";
        sauce = "Marinara sauce";
        toppings.add("Sliced Pepperoni");
        toppings.add("Sliced Onion");
        toppings.add("Grated parmesan cheese");
    }
}

class VeggiePizza extends Pizza{
    public VeggiePizza(){
        name = "Veggie Pizza";
        dough = "Crust";
        sauce = "Marinara sauce";
        toppings.add("Shredded mozzarella");
        toppings.add("Grated parmesan");
        toppings.add("Diced onion");
        toppings.add("Sliced mushrooms");
        toppings.add("Sliced red pepper");
        toppings.add("Sliced black olives");
    }
}

//简单工厂类
class SimplePizzaFactory{
    public Pizza createPizza(String type){
        Pizza pizza = null;
        if(type.equals("cheese")){
            pizza = new CheesePizza();
        }else if(type.equals("pepperoni")){
            pizza = new PepperoniPizza();
        }else if(type.equals("clam")){
            pizza = new ClamPizza();
        }else if(type.equals("veggie")){
            pizza = new VeggiePizza();
        }
        return pizza;
    }
}

class PizzaStore {
    SimplePizzaFactory factory;
    public PizzaStore(SimplePizzaFactory factory){
        this.factory = factory;
    }
    public Pizza orderPizza(String type){
        Pizza pizza = factory.createPizza(type);

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

        return pizza;
    }
}

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

        Pizza pizza = store.orderPizza("cheese");
        System.out.println("We ordered a " + pizza.getName() + "\n");
        System.out.println(pizza);

        pizza = store.orderPizza("veggie");
        System.out.println("We ordered a " + pizza.getName() + "\n");
        System.out.println(pizza);
    }
}

Pizaa工厂实例

（1）下面来到工厂方法模式，与简单工厂不同，工厂方法模式将对象创建移到商店类的createPizza方法中，不同的商店可以创建自己的不同风味的pizza。
（2）不同的加盟店制作的Pizza流程相同，但假如的原料不同，这才形成了不同加盟店独特风味的披萨。

package FactoryPattern.PizzaStore_Factory_pattern;

import java.util.ArrayList;


//Pizza抽象类
abstract class Pizza {
    String name;
    String dough;
    String sauce;
    ArrayList<String> toppings = new ArrayList<>();

    void prepare() {
        System.out.println("Prepare " + name);
        System.out.println("Tossing dough...");
        System.out.println("Adding toppings: ");
        for (String topping : toppings) {
            System.out.println("   " + topping);
        }
    }

    void bake() {
        System.out.println("Bake for 25 minutes at 350");
    }
    void cut(){
        System.out.println("Cut the pizza into diagonal slices");
    }
    void box(){
        System.out.println("Place pizza in official PizzaStore box");
    }

    public String getName(){
        return name;
    }

    public String toString(){
        StringBuffer display = new StringBuffer();
        display.append("---- " + name + " ----\n");
        display.append(dough + "\n");
        display.append(sauce + "\n");
        for(String topping : toppings){
            display.append(topping + "\n");
        }
        return display.toString();
    }
}

//Pizza商店抽象类
abstract class PizzaStore{
    abstract Pizza createPizza(String item);

    public Pizza orderPizza(String type){
        Pizza pizza = createPizza(type);
        System.out.println("--- Making a " + pizza.getName() + " ---");
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
}

//不同商店不同风格的Pizza类
class ChicagoStyleCheesePizza extends Pizza{
    public ChicagoStyleCheesePizza(){
        name = "Chicago Style Deep Dish Cheese Pizza";
        dough = "Extra Thick Crust Dough";
        sauce = "Plum Tomato Sauce";

        toppings.add("Shredded Mozzarella Cheese");
    }

    void cut(){
        System.out.println("Cutting the pizza into square slices");
    }
}

class ChicagoStyleClamPizza extends Pizza{
    public ChicagoStyleClamPizza(){
        name = "Chicago Style Clam Pizza";
        dough = "Extra Thick Crust Dough";
        sauce = "Plum Tomato Sauce";

        toppings.add("Shredded Mozzarella Cheese");
        toppings.add("Frozen Clams from Chesapeake Bay");
    }

    void cut(){
        System.out.println("Cutting the pizza into square slices");
    }
}

class ChicagoStylePepperoniPizza extends Pizza{
    public ChicagoStylePepperoniPizza(){
        name = "Chicago Style Pepperoni Pizza";
        dough = "Extra Thick Crust Dough";
        sauce = "Plum Tomato Sauce";
        toppings.add("Shredded Mozzarella Cheese");
        toppings.add("Black Olives");
        toppings.add("Spinach");
        toppings.add("Eggplant");
        toppings.add("Sliced Pepperoni");
    }

    void cut(){
        System.out.println("Cutting the pizza into square slices");
    }
}

class ChicagoStyleVeggiePizza extends Pizza{
    public ChicagoStyleVeggiePizza(){
        name = "Chicago Deep Dish Veggie Pizza";
        dough = "Extra Thick Crust Dough";
        sauce = "Plum Tomato Sauce";

        toppings.add("Shredded Mozzarella Cheese");
        toppings.add("Black Olives");
        toppings.add("Spinach");
        toppings.add("Eggplant");
    }

    void cut(){
        System.out.println("Cutting the pizza into square slices");
    }
}

class NYStyleCheesePizza extends Pizza{
    public NYStyleCheesePizza(){
        name = "NY Style Sauce and Cheese Pizza";
        dough = "Thin Crust Dough";
        sauce = "Marinara Sauce";

        toppings.add("Grated Reggiano Cheese");
    }
}

class NYStyleClamPizza extends Pizza{
    public NYStyleClamPizza(){
        name = "NY Style Clam Pizza";
        dough = "Thin Crust Dough";
        sauce = "Marinara Sauce";

        toppings.add("Grated Reggiano Cheese");
        toppings.add("Fresh Clams from Long Island Sound");
    }
}

class NYStylePepperoniPizza extends Pizza{
    public NYStylePepperoniPizza(){
        name = "NY Style Pepperoni Pizza";
        dough = "Thin Crust Dough";
        sauce = "Marinara Sauce";

        toppings.add("Grated Reggiano Cheese");
        toppings.add("Sliced Pepperoni");
        toppings.add("Garlic");
        toppings.add("Onion");
        toppings.add("Mushrooms");
        toppings.add("Red Pepper");
    }
}

class NYStyleVeggiePizza extends Pizza{
    public NYStyleVeggiePizza(){
        name = "NY Style Veggie Pizza";
        dough = "Thin Crust Dough";
        sauce = "Marinara Sauce";

        toppings.add("Grated Reggiano Cheese");
        toppings.add("Garlic");
        toppings.add("Onion");
        toppings.add("Mushrooms");
        toppings.add("Red Pepper");
    }
}

//不同商店类
class ChicagoPizzaStore extends PizzaStore{
    @Override
    Pizza createPizza(String item) {
        if(item.equals("cheese")) {
            return new ChicagoStyleCheesePizza();
        }else if(item.equals("veggie")){
            return new ChicagoStyleVeggiePizza();
        }else if(item.equals("clam")){
            return new ChicagoStyleClamPizza();
        }else if(item.equals("pepperoni")){
            return new ChicagoStylePepperoniPizza();
        }else return null;
    }
}

class NYPizzaStore extends PizzaStore{
    @Override
    Pizza createPizza(String item) {
        if(item.equals("cheese")){
            return new NYStyleCheesePizza();
        }else if(item.equals("veggie")){
            return new NYStyleVeggiePizza();
        }else if(item.equals("clam")){
            return new NYStyleClamPizza();
        }else if(item.equals("pepperoni")){
            return new NYStylePepperoniPizza();
        }else return null;
    }
}

//自主商店类
class DependentPizzaStore{
    public Pizza createPizza(String style, String type){
        Pizza pizza = null;
        if(style.equals("NY")){
            if(type.equals("cheese")) {
                pizza = new ChicagoStyleCheesePizza();
            }else if(type.equals("veggie")){
                pizza = new ChicagoStyleVeggiePizza();
            }else if(type.equals("clam")){
                pizza = new ChicagoStyleClamPizza();
            }else if(type.equals("pepperoni")) {
                pizza = new ChicagoStylePepperoniPizza();
            }
        }else if(style.equals("Chicago")){
            if(type.equals("cheese")){
                return new NYStyleCheesePizza();
            }else if(type.equals("veggie")){
                return new NYStyleVeggiePizza();
            }else if(type.equals("clam")){
                return new NYStyleClamPizza();
            }else if(type.equals("pepperoni")) {
                return new NYStylePepperoniPizza();
            }
        }else{
            System.out.println("Error: invalid type of pizza");
            return null;
        }
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }

}
public class PizzaTestDrive {
    public static void main(String[] args){
        PizzaStore nyStore = new NYPizzaStore();
        PizzaStore chicagoStore = new ChicagoPizzaStore();

        Pizza pizza = nyStore.orderPizza("cheese");
        System.out.println("Ethan ordered a " + pizza.getName() + "\n");

        pizza = chicagoStore.orderPizza("cheese");
        System.out.println("Joel ordered a " + pizza.getName() + "\n");

        pizza = nyStore.orderPizza("clam");
        System.out.println("Ethan ordered a " + pizza.getName() + "\n");

        pizza = chicagoStore.orderPizza("clam");
        System.out.println("Joel ordered a " + pizza.getName() + "\n");

        pizza = nyStore.orderPizza("pepperoni");
        System.out.println("Ethan ordered a " + pizza.getName() + "\n");

        pizza = chicagoStore.orderPizza("pepperoni");
        System.out.println("Joel ordered a " + pizza.getName() + "\n");

        pizza = nyStore.orderPizza("veggie");
        System.out.println("Ethan ordered a " + pizza.getName() + "\n");

        pizza = chicagoStore.orderPizza("veggie");
        System.out.println("Joel ordered a " + pizza.getName() + "\n");
    }
}

Pizza抽象工厂实例

（1）与之前又不同，抽象工厂模式创建一组相关或依赖的对象，这里就是为不同的商店的披萨配备不同的佐料；
（2）现在需要考虑确保每家加盟店使用高质量的原料，并将原料运送到各家加盟店。当然原料类是相同的，但是不同加盟店需要的同种原料可能不同，用料的组合也不同，这就需要继承抽象工厂类拓展成不同风格的原料家族，不同加盟店选择不同的工厂类生产的原料进行披萨制作即可。
（3）同一类的披萨，比如CheesePizza，不同加盟店都有！但是用料不同！通过不同加盟店自己的工厂类进行佐料添加即可，避免了上一个工厂方法中，Pizza子类过多的问题，因为同类型的披萨，只需要通过不同的原料工厂类就能够得到不同加盟店自己风味的披萨了！

package FactoryPattern.PizzaStore_Abstract_Factory_Pattern;

//原料接口
interface Cheese { //芝士
    String toString();
}

interface Clams { //蛤蜊
    String toString();
}

interface Dough { //面团
    String toString();
}

interface Sauce { //调味汁
    String toString();
}

interface Veggies { //蔬菜
    String toString();
}

interface Pepperoni { //意大利辣香肠
    String toString();
}

//Pizza原料工厂接口
interface PizzaIngredientFactory{
    Dough createDough();
    Sauce createSauce();
    Cheese createCheese();
    Veggies[] createVeggies();
    Pepperoni createPepperoni();
    Clams createClams();
}

//Pizza抽象类
abstract class Pizza {
    String name;
    Dough dough;
    Sauce sauce;
    Veggies[] veggies;
    Cheese cheese;
    Pepperoni pepperoni;
    Clams clams;

    abstract void prepare();

    void bake() {
        System.out.println("Bake for 25 minutes at 250");
    }

    void cut() {
        System.out.println("Cutting the pizza into diagonal slices");
    }

    void box() {
        System.out.println("Place pizza in official PizzaStore box");
    }

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

    String getName() {
        return name;
    }

    public String toString() {
        StringBuffer result = new StringBuffer();
        result.append("---- " + name + " ----\n");
        if (dough != null) {
            result.append(dough);
            result.append("\n");
        }
        if (sauce != null) {
            result.append(sauce);
            result.append("\n");
        }
        if (cheese != null) {
            result.append(cheese);
            result.append("\n");
        }
        if (veggies != null) {
            for (int i = 0; i < veggies.length; i++) {
                result.append(veggies[i]);
                if(i<veggies.length-1){
                    result.append(", ");
                }
            }
            result.append("\n");
        }
        if(clams != null){
            result.append(clams);
            result.append("\n");
        }
        if(pepperoni != null){
            result.append(pepperoni);
            result.append("\n");
        }
        return result.toString();
    }
}

//Pizza商店抽象类
abstract class PizzaStore{
    protected abstract Pizza createPizza(String item);

    public Pizza orderPizza(String type){
        Pizza pizza = createPizza(type);
        System.out.println("--- Making a " + pizza.getName() + " ---");
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
}

//原料类
class Eggplant implements Veggies{
    public String toString(){
        return "Eggplant";
    }
}

class Garlic implements Veggies{
    public String toString(){
        return "Garlic";
    }
}

class Mushroom implements Veggies{
    public String toString(){
        return "Mushrooms";
    }
}

class Onion implements Veggies{
    public String toString(){
        return "Onion";
    }
}

class RedPepper implements Veggies{
    public String toString(){
        return "Red Pepper";
    }
}

class BlackOlives implements Veggies{
    public String toString(){
        return "Black Olives";
    }
}

class Spinach implements Veggies{
    public String toString(){
        return "Spinach";
    }
}

class FreshClams implements Clams{
    public String toString(){
        return "Fresh Clams from Long Island Sound";
    }
}

class FrozenClams implements Clams{
    public String toString(){
        return "Frozen Clams from Chesapeake Bay";
    }
}

class MarinaraSauce implements Sauce{
    public String toString(){
        return "Marinara Sauce";
    }
}

class PlumTomatoSauce implements Sauce{
    public String toString(){
        return "Tomato sauce with plum tomatoes";
    }
}

class MozzarellaCheese implements Cheese{
    public String toString(){
        return "Shredded Mozzarella";
    }
}

class ParmesanCheese implements Cheese{
    public String toString(){
        return "Shredded Parmesan";
    }
}

class ReggianoCheese implements Cheese{
    public String toString(){
        return "Reggiano Cheese";
    }
}

class SlicedPepperoni implements Pepperoni{
    public String toString(){
        return "Sliced Pepperoni";
    }
}

class ThickCrustDough implements Dough{
    public String toString(){
        return "ThickCrust style extra thick crust dough";
    }
}

class ThinCrustDough implements Dough{
    public String toString(){
        return "Thin Crust Dough";
    }
}

//Pizza类
class CheesePizza extends Pizza{
    PizzaIngredientFactory ingredientFactory;
    public CheesePizza(PizzaIngredientFactory ingredientFactory){
        this.ingredientFactory = ingredientFactory;
    }

    @Override
    void prepare() {
        System.out.println("Preparing " + name);
        dough = ingredientFactory.createDough();
        sauce = ingredientFactory.createSauce();
        cheese = ingredientFactory.createCheese();
    }
}

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

    @Override
    void prepare() {
        System.out.println("Preparing " + name);
        dough = ingredientFactory.createDough();
        sauce = ingredientFactory.createSauce();
        cheese = ingredientFactory.createCheese();
        clams = ingredientFactory.createClams();
    }
}

class PepperoniPizza extends Pizza{
    PizzaIngredientFactory ingredientFactory;
    public PepperoniPizza(PizzaIngredientFactory ingredientFactory){
        this.ingredientFactory = ingredientFactory;
    }

    @Override
    void prepare() {
        System.out.println("Preparing " + name);
        dough = ingredientFactory.createDough();
        sauce = ingredientFactory.createSauce();
        cheese = ingredientFactory.createCheese();
        veggies = ingredientFactory.createVeggies();
        pepperoni = ingredientFactory.createPepperoni();
    }
}

class VeggiePizza extends Pizza{
    PizzaIngredientFactory ingredientFactory;
    public VeggiePizza(PizzaIngredientFactory ingredientFactory){
        this.ingredientFactory = ingredientFactory;
    }

    @Override
    void prepare() {
        System.out.println("Preparing " + name);
        dough = ingredientFactory.createDough();
        sauce = ingredientFactory.createSauce();
        cheese = ingredientFactory.createCheese();
        veggies = ingredientFactory.createVeggies();
    }
}

//原料工厂类
class ChicagoPizzaIngredientFactory implements PizzaIngredientFactory{
    @Override
    public Dough createDough() {
        return new ThickCrustDough();
    }

    @Override
    public Sauce createSauce() {
        return new PlumTomatoSauce();
    }

    @Override
    public Cheese createCheese() {
        return new MozzarellaCheese();
    }

    @Override
    public Veggies[] createVeggies() {
         Veggies[] veggies = {
                new BlackOlives(),
                new Spinach(),
                new Eggplant()
        };
        return veggies;
    }

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

    @Override
    public Clams createClams() {
        return new FrozenClams();
    }
}

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

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

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

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

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

    @Override
    public Clams createClams() {
        return new FreshClams();
    }
}

//Pizza商店类
class ChicagoPizzaStore extends PizzaStore{
    @Override
    protected Pizza createPizza(String item) {
        Pizza pizza = null;
        PizzaIngredientFactory ingredientFactory = new ChicagoPizzaIngredientFactory();

        if(item.equals("cheese")){
            pizza = new CheesePizza(ingredientFactory);
            pizza.setName("Chicago Style Cheese Pizza");
        }else if(item.equals("veggie")){
            pizza = new VeggiePizza(ingredientFactory);
            pizza.setName("Chicago Style Veggie Pizza");
        }else if(item.equals("clam")){
            pizza = new ClamPizza(ingredientFactory);
            pizza.setName("Chicago Style Clam Pizza");
        }else if(item.equals("pepperoni")){
            pizza = new PepperoniPizza(ingredientFactory);
            pizza.setName("Chicago Style Pepperoni Pizza");
        }
        return pizza;
    }
}

class NYPizzaStore extends PizzaStore{
    @Override
    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("veggie")){
            pizza = new VeggiePizza(ingredientFactory);
            pizza.setName("New York Style Veggie Pizza");
        }else if(item.equals("clam")){
            pizza = new ClamPizza(ingredientFactory);
            pizza.setName("New York Style Clam Pizza");
        }else if(item.equals("pepperoni")){
            pizza = new PepperoniPizza(ingredientFactory);
            pizza.setName("New York Style Pepperoni Pizza");
        }
        return pizza;
    }
}
public class PizzaTestDrive {
    public static void main(String[] args){
        PizzaStore nyStore = new NYPizzaStore();
        PizzaStore chicagoStore = new ChicagoPizzaStore();

        Pizza pizza = nyStore.orderPizza("cheese");
        System.out.println("Ethan ordered a " + pizza + "\n");

        pizza = chicagoStore.orderPizza("cheese");
        System.out.println("Joel ordered a " + pizza + "\n");

        pizza = nyStore.orderPizza("clam");
        System.out.println("Ethan ordered a " + pizza + "\n");

        pizza = chicagoStore.orderPizza("clam");
        System.out.println("Joel ordered a " + pizza + "\n");

        pizza = nyStore.orderPizza("pepperoni");
        System.out.println("Ehan ordered a " + pizza + "\n");

        pizza = chicagoStore.orderPizza("pepperoni");
        System.out.println("Joel ordered a " + pizza + "\n");

        pizza = nyStore.orderPizza("veggie");
        System.out.println("Ethan ordered a " + pizza + "\n");

        pizza = chicagoStore.orderPizza("veggie");
        System.out.println("Joel ordered a " + pizza + "\n");
    }
}

四则运算简单工厂实例

package com.louris.demo;
import java.util.Scanner;


public class Test {

    public static void main(String[] args) {
//        try{
//            Scanner in = new Scanner(System.in);
//            System.out.println("Please input number A: ");
//            String strNumberA = in.nextLine();
//            System.out.println("Please input opreator: ");
//            String strOperate = in.nextLine();
//            char chOperate = strOperate.charAt(0);
//            System.out.println("Please input number B: ");
//            String strNumberB = in.nextLine();
//            String strResult = "";
//            strResult = String.valueOf(Operation.GetResult(Double.parseDouble(strNumberA), Double.parseDouble(strNumberB), chOperate));
//            System.out.println("Result: ");
//            System.out.println(strResult);
//        }catch (Exception e){
//            System.out.println("Input error!");
//        }

        Operation op = OperationFactory.createOperation('/');
        op.setNumberA(1);
        op.setNumberB(0);
        try{
            double result = op.getResult();
            System.out.println(result);
        }catch (Exception e){
            System.out.println(e.toString());
        }


    }
}

class Operation {
//    public static double GetResult(double numberA, double numberB, char operate) {
//        double result = switch (operate) {
//            case '+' -> numberA + numberB;
//            case '-' -> numberA - numberB;
//            case '*' -> numberA * numberB;
//            case '/' -> numberA / numberB;
//            default -> 0d;
//        };
//        return result;
//    }
    private double _numberA = 0;
    private double _numberB = 0;

    public void setNumberA(double value){
        _numberA = value;
    }
    public void setNumberB(double value){
        _numberB = value;
    }
    public double getNumberA(){return _numberA;}
    public double getNumberB(){return _numberB;}

    // Virtual function for override
    public double getResult() throws Exception {
        double result = 0;
        return result;
    }
}

class OperationAdd extends Operation{
    public double getResult(){
        double result = 0;
        result = getNumberA() + getNumberB();
        return result;
    }
}

class OperationSub extends Operation{
    public double getResult(){
        double result = 0;
        result = getNumberA() - getNumberB();
        return result;
    }
}

class OperationMul extends Operation{
    public double getResult(){
        double result = 0;
        result = getNumberA() * getNumberB();
        return result;
    }
}

class OperationDiv extends Operation{
    public double getResult() throws Exception {
        double result = 0;
        if(getNumberB() == 0)
            throw new Exception("Divisor cannot be zero!");
        result = getNumberA() / getNumberB();
        return result;
    }
}

class OperationFactory{
    public static Operation createOperation(char operate){
        Operation op = switch (operate) {
            case '+' -> new OperationAdd();
            case '-' -> new OperationSub();
            case '*' -> new OperationMul();
            case '/' -> new OperationDiv();
            default -> null;
        };
        return op;
    }
}

单例模式

定义：单例模式确保一个类只有一个实例，并提供一个全局访问点。

多线程的选择
（1）如果getInstance()的性能对应用程序不是很关键，就什么都别做
即使用给方法加同步锁的方式，如果应用程序可以接受该方法造成的额外负担，就无需改动。同步getInstance()方法既简单又有效，但是必须知道，同步一个方法可能造成程序执行率下降100倍，因此，如果将getInstance()的程序使用在频繁运行的地方，就得重新考虑其他方式了。
（2）使用“急切”创建实例，而不用延迟实例化的做法
如果应用程序总是创建并使用单例，或者再创建和运行时方面的负担不太繁重，可能需要急切(early)创建次单例，即使用静态初始化的方式。
（3）用“双重检查加锁”，在getInstance()中减少使用同步
利用双重检查加锁（double-checked locking），首先检查是否实例已经创建了，如果尚未创建，“才”进行同步。这样一来，只要第一次会同步，效率更高！

经典单例模式

线程不安全

package SingletonPattern.Classic;

class Singleton{
    private static Singleton uniqueInstance;

    private Singleton(){}

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

    public String getDescription(){
        return "I'm a classic Singleton!";
    }
}
public class SingletonClient {
    public static void main(String[] args){
        Singleton singleton = Singleton.getInstance();
        System.out.println(singleton.getDescription());
    }
}

线程安全单例模式

线程安全，但是每次调用getInstance()方法不管是否已经实例化了都需要同步操作，效率低下！

package SingletonPattern.ThreadSafe;

class Singleton {
    private static Singleton uniqueInstance;

    private Singleton() {}

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

    public String getDescription(){
        return "I'm a thread safe Singleton!";
    }
}

public class SingletonClient {
    public static void main(String[] args){
        Singleton singleton=Singleton.getInstance();
        System.out.println(singleton.getDescription());
    }
}

静态初始化单例模式

package SingletonPattern.Stat;

class Singleton{
    private static Singleton uniqueInstance = new Singleton();

    private Singleton(){}

    public static Singleton getInstance(){
        return uniqueInstance;
    }

    public String getDescription(){
        return "I'm a statically initialized Singleton!";
    }
}
public class SingletonClient {
    public static void main(String[] args){
        Singleton singleton = Singleton.getInstance();
        System.out.println(singleton.getDescription());
    }
}

双重检查单例模式

相较于之前的线程安全的给方法加同步锁的方式来说，这样更为高效！

package SingletonPattern.DoubleCheckLocking;

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 String getDescription(){
        return "I'm a double-check locking Singleton!";
    }
}
public class SingletonClient {
    public static void main(String[] args){
        Singleton singleton = Singleton.getInstance();
        System.out.println(singleton.getDescription());
    }
}

巧克力工厂锅炉实例

package SingletonPattern.Chocolate;

class ChocolateBoiler{
    private boolean empty;
    private boolean boiled;
    private static ChocolateBoiler uniqueInstance;

    public static ChocolateBoiler getInstance(){
        if(uniqueInstance == null){
            System.out.println("Creating unique instance of Chocolate Boiler");
            uniqueInstance = new ChocolateBoiler();
        }
        System.out.println("Returning instance of Chocolate Boiler");
        return uniqueInstance;
    }

    public void fill(){
        if(isEmpty()){
            empty = false;
            boiled = false;
            // fill the boiler with a milk/chocolate mixture
        }
    }

    public void drain(){
        if(!isEmpty()&&isBoiled()){
            //drain the boiled milk and chocolate
            empty = true;
        }
    }

    public void boil(){
        if(!isEmpty()&&!isBoiled()){
            //bring the contents to a boil
            boiled = true;
        }
    }

    public boolean isEmpty() {
        return empty;
    }

    public boolean isBoiled() {
        return boiled;
    }
}
public class ChocolateController {
    public static void main(String args[]){
        ChocolateBoiler boiler = ChocolateBoiler.getInstance();
        boiler.fill();
        boiler.boil();
        boiler.drain();

        //will return the existing instance
        ChocolateBoiler boiler1 = ChocolateBoiler.getInstance();
    }
}

命令模式

定义：命令模式将“请求”封装成对象，以便使用不同的请求、队列或者日志来参数化其他对象，命令模式也支持可撤销的操作。

（1）首先，来看看本章的问题：遥控器有七个插槽，每个插槽都有其对应的开关按钮，并且另外还有一个撤销按钮；而由一堆厂商类，例如Light，CeilingLight，TV，GarageDoor等等，每种类分别有其自己的on()，off()等方法。

（2）一个比较简单而可行的设计思路：遥控器应该知道如何解读按钮被按下的动作，然后发出正确的请求，但是遥控器不需要知道这些家电自动化的细节，或者如何打开热水器等。 —— 总不想在代码中包含一堆if语句判断各个插槽是啥类型，然后相对应操作吧？不利于拓展和维护！
（3）命令模式可以将“动作的请求者”从“动作的执行者”对象中解耦。如果对每个按钮都存储一个命令对象，那么当按钮按下的时候，就可以请命令对象做相关的工作。遥控器并不需要知道工作内容是什么，只要有个命令对象能和正确的对象沟通，把事情做好就可以了。所以，遥控器就和具体的电气类对象解耦了！
（4）创建一个API，将这些命令对象加载到按钮插槽，让遥控器的代码尽量保持简单。而把家电自动化的工作和进行该工作的对象一起封装在命令对象中。

简单命令模式实例

package CommandPattern.SimpleRemote;

@FunctionalInterface
interface Command{
    void execute();
}

//Invoker
class SimpleRemoteControl{
    Command slot;

    public SimpleRemoteControl(){}

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

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

//Receiver
class GarageDoor{
    public GarageDoor(){}

    public void up(){
        System.out.println("Garage Door is Open.");
    }

    public void down(){
        System.out.println("Garage Door is Closed.");
    }

    public void stop(){
        System.out.println("Garage Door is Stopped.");
    }

    public void lightOn(){
        System.out.println("Garage light is on.");
    }

    public void lightOff(){
        System.out.println("Garage light is off.");
    }
}

class Light{
    public Light(){}

    public void on(){
        System.out.println("Light is on.");
    }

    public void off(){
        System.out.println("Light is off.");
    }
}

//Command类
class LightOnCommand implements Command{
    Light light;

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

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

class LightOffCommand implements Command{
    Light light;

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

    @Override
    public void execute() {
        light.off();
    }
}

class GarageDoorOpenCommand implements Command{
    GarageDoor garageDoor;

    public GarageDoorOpenCommand(GarageDoor garageDoor){
        this.garageDoor = garageDoor;
    }

    @Override
    public void execute() {
        garageDoor.up();
    }
}
public class RemoteControlTest {
    public static void main(String[] args){
        SimpleRemoteControl remote = new SimpleRemoteControl();
        Light light = new Light();
        GarageDoor garageDoor = new GarageDoor();
        LightOnCommand lightOnCommand = new LightOnCommand(light);
        GarageDoorOpenCommand garageDoorOpenCommand = new GarageDoorOpenCommand(garageDoor);

        remote.setCommand(lightOnCommand);
        remote.buttonWasPressed();
        remote.setCommand(garageDoorOpenCommand);
        remote.buttonWasPressed();
    }
}

简单命令模式Lambda

package CommandPattern.SimpleRemoteWL;

@FunctionalInterface
interface Command{
    void execute();
}

//Invoker
class SimpleRemoteControl{
    Command slot; //卡槽

    public SimpleRemoteControl(){}

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

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

//Receiver类
class Light{
    public Light(){}

    public void on(){
        System.out.println("Light is on.");
    }

    public void off(){
        System.out.println("Light is off.");
    }
}

class GarageDoor{
    public GarageDoor(){}

    public void up(){
        System.out.println("Garage Door is Open.");
    }

    public void down(){
        System.out.println("Garage Door is Closed.");
    }

    public void stop(){
        System.out.println("Garage Door is Stopped.");
    }
    public void lightOn(){
        System.out.println("Garage light is on.");
    }

    public void lightOff(){
        System.out.println("Garage light is off.");
    }
}
public class RemoteControlTest {
    public static void main(String[] args){
        SimpleRemoteControl remote = new SimpleRemoteControl();
        Light light = new Light();
        GarageDoor garageDoor = new GarageDoor();
        //函数式调用
        remote.setCommand(light::on);
        remote.buttonWasPressed();
        remote.setCommand(garageDoor::up);
        remote.buttonWasPressed();
        remote.setCommand(garageDoor::lightOn);
        remote.buttonWasPressed();
        remote.setCommand(garageDoor::lightOff);
        remote.buttonWasPressed();
    }
}

餐厅实例

package CommandPattern.Diner;

import javax.swing.plaf.IconUIResource;

@FunctionalInterface
interface Order{
    void orderUp();
}


class Waitress{
    Order order;
    public Waitress(){}

    public void takeOrder(Order order){
        this.order = order;
        order.orderUp();
    }
}

//Command类
class BurgerAndFriesOrder implements Order{
    Cook cook;
    public BurgerAndFriesOrder(Cook cook){
        this.cook = cook;
    }

    @Override
    public void orderUp() {
        cook.makeBurger();
        cook.makeFries();
    }
}
//Receiver
class Cook{
    public Cook(){}

    public void makeBurger(){
        System.out.println("Making a burger.");
    }

    public void makeFries(){
        System.out.println("Making fries.");
    }
}

//Customer
class Customer{
    Waitress waitress;
    Order order;

    public Customer(Waitress waitress){
        this.waitress = waitress;
    }

    public void createOrder(Order order){
        this.order = order;
    }

    public void hungry(){
        waitress.takeOrder(order);
    }
}
public class DinerTest {
    public static void main(String[] args){
        Cook cook = new Cook();
        Waitress waitress = new Waitress();
        Customer customer = new Customer(waitress);
        customer.createOrder(new BurgerAndFriesOrder(cook));
        customer.hungry();
    }
}

餐厅实例Lambda

package CommandPattern.DinerLambda;

@FunctionalInterface
interface Order{
    void orderUp();
}

class Waitress{
    Order order;

    public Waitress(){}

    public void takeOrder(Order order){
        this.order = order;
        order.orderUp();
    }
}

class Cook{

    public Cook(){}

    public void makeBurger(){
        System.out.println("Making a burger.");
    }

    public void makeFries(){
        System.out.println("Making fries.");
    }
}

class Customer{
    Waitress waitress;
//    Cook cook;
    Order order;

    public Customer(Waitress waitress/*, Cook cook*/){
        this.waitress = waitress;
//        this.cook = cook;
    }

    public void createOrder(Order order){
//        order = () -> {cook.makeBurger();cook.makeFries();};
        this.order = order;
    }

    public void hungry(){
        waitress.takeOrder(order);
    }
}

public class DinerTest {
    public static void main(String[] args){
        Cook cook = new Cook();
        Waitress waitress = new Waitress();
        Customer customer = new Customer(waitress/*, cook*/);
        customer.createOrder(()->{cook.makeBurger();cook.makeFries();});
        customer.hungry();
    }
}

遥控器实例

package CommandPattern.Remote;

import java.util.concurrent.ConcurrentMap;

@FunctionalInterface
interface Command{
    void execute();
}

//Receiver
class CeilingFan{
    String location = "";
    int level;
    public static final int HIGH = 2;
    public static final int MEDIUM = 1;
    public static final int LOW = 0;

    public CeilingFan(String location){
        this.location = location;
    }

    public void high(){
        level = HIGH;
        System.out.println(location + " ceiling fan is on high.");
    }

    public void medium(){
        level = MEDIUM;
        System.out.println(location + " ceiling fan is on low.");
    }

    public void low(){
        level = LOW;
        System.out.println(location + " ceiling fan is on low.");
    }

    public void off(){
        level = 0;
        System.out.println(location + " ceiling fan is off.");
    }

    public int getSpeed(){
        return level;
    }
}

class GarageDoor{
    String location;

    public GarageDoor(String location){
        this.location = location;
    }

    public void up(){
        System.out.println(location + " garage Door is Up.");
    }

    public void down(){
        System.out.println(location + " garage Door is Down.");
    }

    public void stop(){
        System.out.println(location + " garage Door is Stopped.");
    }

    public void lightOn(){
        System.out.println(location + " garage light is on.");
    }

    public void lightOff(){
        System.out.println(location + " garage light is off.");
    }
}

class Hottub{
    boolean on;
    int temperature;

    public Hottub(){}

    public void on(){
        on = true;
    }

    public void off(){
        on = false;
    }

    public void bubblesOn(){
        if(on){
            System.out.println("Hottub is bubbling!");
        }
    }

    public void bubblesOff(){
        if(on){
            System.out.println("Hottub is not bubbling!");
        }
    }

    public void jetsOn(){
        if(on){
            System.out.println("Hottub jets are on.");
        }
    }

    public void jetsOff(){
        if(on){
            System.out.println("Hottub jets are off.");
        }
    }

    public void setTemperature(int temperature){
        this.temperature = temperature;
    }

    public void heat(){
        temperature = 105;
        System.out.println("Hottub is heating to a steaming 105 degrees.");
    }

    public void cool(){
        temperature = 98;
        System.out.println("Hottub is cooling to 98 degrees.");
    }
}

class Light{
    String location = "";

    public Light(String location){
        this.location = location;
    }

    public void on(){
        System.out.println(location + " light is on.");
    }

    public void off(){
        System.out.println(location + " light is off.");
    }
}

class Stereo{
    String location;

    public Stereo(String location){
        this.location = location;
    }

    public void on(){
        System.out.println(location + " stereo is on.");
    }

    public void off(){
        System.out.println(location + " stereo is off.");
    }

    public void setCD(){
        System.out.println(location + " stereo is set for CD input.");
    }

    public void setDVD(){
        System.out.println(location + " stereo is set for DVD input.");
    }

    public void setRadio(){
        System.out.println(location + " stereo is set for Radio.");
    }

    public void setVolume(int volume){
        System.out.println(location + " Stereo volume set to " + volume);
    }
}

class TV{
    String location;
    int channel;

    public TV(String location){
        this.location = location;
    }

    public void on(){
        System.out.println("TV is on.");
    }

    public void off(){
        System.out.println("TV is off.");
    }

    public void setInputChannel(){
        this.channel = 3;
        System.out.println("Channel is set for VCR.");
    }
}

//Command类
class CeilingFanOnCommand implements Command{
    CeilingFan ceilingFan;

    public CeilingFanOnCommand(CeilingFan ceilingFan){
        this.ceilingFan = ceilingFan;
    }

    @Override
    public void execute() {
        ceilingFan.high();
    }
}

class CeilingFanOffCommand implements Command{
    CeilingFan ceilingFan;

    public CeilingFanOffCommand(CeilingFan ceilingFan){
        this.ceilingFan = ceilingFan;
    }

    @Override
    public void execute(){
        ceilingFan.off();
    }
}

class GarageDoorUpCommand implements Command{
    GarageDoor garageDoor;

    public GarageDoorUpCommand(GarageDoor garageDoor){
        this.garageDoor = garageDoor;
    }

    @Override
    public void execute() {
        garageDoor.up();
    }
}

class GarageDoorDownCommand implements Command{
    GarageDoor garageDoor;

    public GarageDoorDownCommand(GarageDoor garageDoor){
        this.garageDoor = garageDoor;
    }

    @Override
    public void execute() {
        garageDoor.down();
    }
}

class HottubOnCommand implements Command{
    Hottub hottub;

    public HottubOnCommand(Hottub hottub){
        this.hottub = hottub;
    }

    @Override
    public void execute() {
        hottub.on();
        hottub.heat();
        hottub.bubblesOn();
    }
}

class HottubOffCommand implements Command{
    Hottub hottub;

    public HottubOffCommand(Hottub hottub){
        this.hottub = hottub;
    }

    @Override
    public void execute() {
        hottub.cool();
        hottub.off();
    }
}

class LightOnCommand implements Command{
    Light light;

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

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

class LightOffCommand implements Command{
    Light light;

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

    @Override
    public void execute() {
        light.off();
    }
}

class LivingroomLightOnCommand implements Command{
    Light light;

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

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

class LivingroomLightOffCommand implements Command{
    Light light;
    public LivingroomLightOffCommand(Light light){
        this.light = light;
    }

    @Override
    public void execute() {
        light.off();
    }
}

class StereoOnWithCDCommand implements Command{
    Stereo stereo;

    public StereoOnWithCDCommand(Stereo stereo){
        this.stereo = stereo;
    }

    @Override
    public void execute() {
        stereo.on();
        stereo.setCD();
        stereo.setVolume(11);
    }
}

class StereoOffCommand implements Command{
    Stereo stereo;

    public StereoOffCommand(Stereo stereo){
        this.stereo = stereo;
    }

    @Override
    public void execute() {
        stereo.off();
    }
}

class NoCommand implements Command{
    @Override
    public void execute() {

    }
}

//Invoker
class RemoteControl{
    Command[] onCommands;
    Command[] offCommands;

    public RemoteControl(){
        onCommands = new Command[7];
        offCommands = new Command[7];

        Command noCommand = new NoCommand();
        for(int i=0;i<7;i++){
            onCommands[i] = noCommand;
            offCommands[i] = noCommand;
        }
    }

    public void setCommand(int slot, Command onCommand, Command offCommand){
        onCommands[slot] = onCommand;
        offCommands[slot] = offCommand;
    }

    public void onButtonWasPushed(int slot){
        onCommands[slot].execute();
    }

    public void offButtonWasPushed(int slot){
        offCommands[slot].execute();
    }

    public String toString(){
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("\n------ Remote Control ------\n");
        for(int i=0;i<onCommands.length;i++){
            stringBuffer.append("[slot " + i + "] " + onCommands[i].getClass().getName()
            + "    " + offCommands[i].getClass().getName() + "\n");
        }
        return stringBuffer.toString();
    }
}
public class RemoteLoader {
    public static void main(String[] args){
        RemoteControl remoteControl = new RemoteControl();

        Light livingRoomLight = new Light("Living Room");
        Light kitchenLight = new Light("Kitchen");
        CeilingFan ceilingFan = new CeilingFan("Living Room");
        GarageDoor garageDoor = new GarageDoor("");
        Stereo stereo = new Stereo("Living Room");

        LightOnCommand livingRoomLightOn = new LightOnCommand(livingRoomLight);
        LightOffCommand livingRoomLightOff = new LightOffCommand(livingRoomLight);

        LightOnCommand kitchenLightOn = new LightOnCommand(kitchenLight);
        LightOffCommand kitchenLightOff = new LightOffCommand(kitchenLight);

        CeilingFanOnCommand ceilingFanOn = new CeilingFanOnCommand(ceilingFan);
        CeilingFanOffCommand ceilingFanOff = new CeilingFanOffCommand(ceilingFan);

        GarageDoorUpCommand garageDoorUp = new GarageDoorUpCommand(garageDoor);
        GarageDoorDownCommand garageDoorDown = new GarageDoorDownCommand(garageDoor);

        StereoOnWithCDCommand stereoOnWithCD = new StereoOnWithCDCommand(stereo);
        StereoOffCommand stereoOff = new StereoOffCommand(stereo);

        remoteControl.setCommand(0, livingRoomLightOn, livingRoomLightOff);
        remoteControl.setCommand(1, kitchenLightOn, kitchenLightOff);
        remoteControl.setCommand(2, ceilingFanOn, ceilingFanOff);
        remoteControl.setCommand(3, stereoOnWithCD, stereoOff);

        System.out.println(remoteControl);

        remoteControl.onButtonWasPushed(0);
        remoteControl.offButtonWasPushed(0);

        remoteControl.onButtonWasPushed(1);
        remoteControl.offButtonWasPushed(1);

        remoteControl.onButtonWasPushed(2);
        remoteControl.offButtonWasPushed(2);

        remoteControl.onButtonWasPushed(3);
        remoteControl.offButtonWasPushed(3);

        //Lambda
        remoteControl.setCommand(0, livingRoomLight::on, livingRoomLight::off);
        remoteControl.setCommand(1, kitchenLight::on, kitchenLight::off);
        remoteControl.setCommand(2, ceilingFan::high, ceilingFan::off);

        Command stereoOnWithCO = ()->{
            stereo.on();stereo.setCD();stereo.setVolume(11);
        };
        remoteControl.setCommand(3, stereoOnWithCO, stereo::off);
        remoteControl.setCommand(4, garageDoor::up, garageDoor::down);

        System.out.println(remoteControl);

        remoteControl.onButtonWasPushed(0);
        remoteControl.offButtonWasPushed(0);

        remoteControl.onButtonWasPushed(1);
        remoteControl.offButtonWasPushed(1);

        remoteControl.onButtonWasPushed(2);
        remoteControl.offButtonWasPushed(2);

        remoteControl.onButtonWasPushed(3);
        remoteControl.offButtonWasPushed(3);

        remoteControl.onButtonWasPushed(4);
        remoteControl.offButtonWasPushed(4);

        remoteControl.onButtonWasPushed(5);
        remoteControl.offButtonWasPushed(5);
    }
}

遥控器实例带撤销以及组合命令

package CommandPattern.RemoteWithUndo;

import java.util.concurrent.ConcurrentMap;

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

//Receiver
class Light{
    String location = "";
    int level;

    public Light(String location){
        this.location = location;
    }

    public void on(){
        level = 100;
        System.out.println(location + " light is on.");
    }

    public void off(){
        level = 0;
        System.out.println(location + " light is off.");
    }

    public void dim(int level){
        this.level = level;
        if(level == 0){
            off();
        }else{
            System.out.println("Light is dimmed to " + level + "%");
        }
    }

    public int getLevel(){
        return level;
    }
}

class CeilingFan{
    String location = "";
    int speed;
    public static final int HIGH = 3;
    public static final int MEDIUM = 2;
    public static final int LOW = 1;
    public static final int OFF = 0;

    public CeilingFan(String location){
        this.location = location;
        speed = OFF;
    }

    public void high(){
        speed = HIGH;
        System.out.println(location + " ceiling fan is on high.");
    }

    public void medium(){
        speed = MEDIUM;
        System.out.println(location + " ceiling fan is on medium.");
    }

    public void low(){
        speed = LOW;
        System.out.println(location + " ceiling fan is on low.");
    }

    public void off(){
        speed = OFF;
        System.out.println(location + " ceiling fan is off.");
    }

    public int getSpeed(){
        return speed;
    }
}

//Command类
abstract class CeilingFanCommand implements Command{
    CeilingFan ceilingFan;
    int prevSpeed;
    @Override
    public void undo() {
        if(prevSpeed == CeilingFan.HIGH){
            ceilingFan.high();
        }else if(prevSpeed == CeilingFan.MEDIUM){
            ceilingFan.medium();
        }else if(prevSpeed == CeilingFan.LOW){
            ceilingFan.low();
        }else if(prevSpeed == CeilingFan.OFF){
            ceilingFan.off();
        }
    }
}
class CeilingFanHighCommand extends CeilingFanCommand{

    public CeilingFanHighCommand(CeilingFan ceilingFan){
        this.ceilingFan = ceilingFan;
    }

    @Override
    public void execute() {
        prevSpeed = ceilingFan.getSpeed();
        ceilingFan.high();
    }
}

class CeilingFanLowCommand extends CeilingFanCommand{

    public CeilingFanLowCommand(CeilingFan ceilingFan){
        this.ceilingFan = ceilingFan;
    }

    @Override
    public void execute() {
        prevSpeed = ceilingFan.getSpeed();
        ceilingFan.low();
    }
}

class CeilingFanMediumCommand extends CeilingFanCommand{
    public CeilingFanMediumCommand(CeilingFan ceilingFan){
        this.ceilingFan = ceilingFan;
    }

    @Override
    public void execute() {
        prevSpeed = ceilingFan.getSpeed();
        ceilingFan.medium();
    }
}

class CeilingFanOffCommand extends CeilingFanCommand{
    public CeilingFanOffCommand(CeilingFan ceilingFan){
        this.ceilingFan = ceilingFan;
    }

    @Override
    public void execute() {
        prevSpeed = ceilingFan.getSpeed();
        ceilingFan.off();
    }
}


abstract class LightCommand implements Command{
    Light light;
    int preLevel;

    @Override
    public void undo() {
        light.dim(preLevel);
    }
}
class LightOnCommand extends LightCommand{
    public LightOnCommand(Light light){
        this.light = light;
    }

    @Override
    public void execute() {
        preLevel = light.getLevel();
        light.on();
    }
}

class LightOffCommand extends LightCommand{
    public LightOffCommand(Light light){
        this.light = light;
    }

    @Override
    public void execute() {
        preLevel = light.getLevel();
        light.off();
    }
}

class DimmerLightOnCommand extends LightCommand{
    public DimmerLightOnCommand(Light light){
        this.light = light;
    }

    @Override
    public void execute() {
        preLevel = light.getLevel();
        light.dim(75);
    }
}

class DimmerLightOffCommand extends LightCommand{
    public DimmerLightOffCommand(Light light){
        this.light = light;
        preLevel = 100;
    }

    @Override
    public void execute() {
        preLevel = light.getLevel();
        light.off();
    }
}

class NoCommand implements Command{
    @Override
    public void execute() {

    }

    @Override
    public void undo() {

    }
}

//宏命令
class MacroCommand implements Command{
    Command[] commands;

    public MacroCommand(Command[] commands){
        this.commands = commands;
    }

    @Override
    public void execute() {
        for(int i=0;i<commands.length;i++){
            commands[i].execute();;
        }
    }
    /*
    Note: these commands have to be done backwards to ensure proper undo functionality.
     */
    @Override
    public void undo() {
        for(int i=commands.length-1;i>=0;i--){
            commands[i].undo();
        }
    }
}
//Invoker
class RemoteControlWithUndo{
    Command[] onCommands;
    Command[] offCommands;
    Command undoCommand;

    public RemoteControlWithUndo(){
        onCommands = new Command[7];
        offCommands = new Command[7];

        Command noCommand = new NoCommand();
        for(int i=0;i<7;i++){
            onCommands[i] = noCommand;
            offCommands[i] = noCommand;
        }
        undoCommand = noCommand;
    }

    public void setCommand(int slot, Command onCommand, Command offCommand) {
        onCommands[slot] = onCommand;
        offCommands[slot] = offCommand;
    }

    public void onButtonWasPushed(int slot) {
        onCommands[slot].execute();
        undoCommand = onCommands[slot];
    }

    public void offButtonWasPushed(int slot) {
        offCommands[slot].execute();
        undoCommand = offCommands[slot];
    }

    public void undoButtonWasPushed() {
        undoCommand.undo();
    }

    public String toString() {
        StringBuffer stringBuff = new StringBuffer();
        stringBuff.append("\n------ Remote Control -------\n");
        for (int i = 0; i < onCommands.length; i++) {
            stringBuff.append("[slot " + i + "] " + onCommands[i].getClass().getName()
                    + "    " + offCommands[i].getClass().getName() + "\n");
        }
        stringBuff.append("[undo] " + undoCommand.getClass().getName() + "\n");
        return stringBuff.toString();
    }
}
public class RemoteLoader {

    public static void main(String[] args){
        RemoteControlWithUndo remoteControl = new RemoteControlWithUndo();

        Light livingRoomLight = new Light("Living Room");

        LightOnCommand livingRoomLightOn = new LightOnCommand(livingRoomLight);
        LightOffCommand livingRoomLightOff = new LightOffCommand(livingRoomLight);

        remoteControl.setCommand(0, livingRoomLightOn, livingRoomLightOff);

        remoteControl.onButtonWasPushed(0);
        remoteControl.offButtonWasPushed(0);

        System.out.println(remoteControl);

        remoteControl.undoButtonWasPushed();
        remoteControl.offButtonWasPushed(0);
        remoteControl.onButtonWasPushed(0);

        System.out.println(remoteControl);

        remoteControl.undoButtonWasPushed();

        CeilingFan ceilingFan = new CeilingFan("Living Room");

        CeilingFanMediumCommand ceilingFanMedium = new CeilingFanMediumCommand(ceilingFan);
        CeilingFanHighCommand ceilingFanHigh = new CeilingFanHighCommand(ceilingFan);
        CeilingFanOffCommand ceilingFanOff = new CeilingFanOffCommand(ceilingFan);

        remoteControl.setCommand(0, ceilingFanMedium, ceilingFanOff);
        remoteControl.setCommand(1, ceilingFanHigh, ceilingFanOff);

        remoteControl.onButtonWasPushed(0);
        remoteControl.offButtonWasPushed(0);
        System.out.println(remoteControl);
        remoteControl.undoButtonWasPushed();

        remoteControl.onButtonWasPushed(1);
        System.out.println(remoteControl);
        remoteControl.undoButtonWasPushed();

        //Party Test
        Command[] partyOn = {livingRoomLightOn, ceilingFanMedium};
        Command[] partyOff = {livingRoomLightOff, ceilingFanOff};
        MacroCommand macroPartyOn = new MacroCommand(partyOn);
        MacroCommand macroPartyOff = new MacroCommand(partyOff);

        remoteControl.setCommand(0, macroPartyOn, macroPartyOff);

        System.out.println(remoteControl);
        System.out.println("---- Pushing Macro On ----");
        remoteControl.onButtonWasPushed(0);
        System.out.println("---- Pushing Macro Off ----");
        remoteControl.offButtonWasPushed(0);
    }
}

命令模式的更多用途：

队列请求

日志请求

适配器模式

对象适配器

定义：适配器模式将一个类的接口，转换成客户端期望的另一个接口，适配器让原本接口不兼容的来可以合作无间。

问
1.一个适配器只能够封装一个类吗？

适配器模式的工作是将一个接口转换成另一个，虽然大多数的适配器模式所采取的例子都是让一个适配器包装一个被适配者，但我们都知道这个世界其实复杂多了，所以你可能遇到一些状况，需要让一个适配器包装多个被适配者。这设计另一个模式——外观模式（Facade Pattern），人们常常将外观模式和适配器模式混为一谈。

2.万一系统中新旧并存，旧的部分期望旧的厂商接口，但我们却已经使用新厂商的接口编写了这一部分，这时候该怎么办？这里使用适配器，那里却使用未包装的接口，这实在是让人感到混乱。如果我只是固守着旧的代码，完全不要管适配器，这样子会不会好一些？

不需要如此，可以创建一个双向的适配器，支持两边的接口。想创建一个双向的适配器，就必须实现所涉及的两个接口，这样，这个适配器可以当做旧的接口，或者当做新的接口使用。
类适配器
类适配器与对象适配器唯一的差别在于适配器继承了Target和Adaptee，而对象适配器利用组合的方式将请求传送给被适配者。

对象适配器与类适配器对比
1.对象适配器使用组合，可以适配某个类及其子类；
2.类适配器只能适配某个特定的被适配类，但其不需要重新实现整个被适配者，必要的时候，也可以覆盖被适配者的行为，因为其利用继承的方式；

适配器模式与装饰者模式区别

（1）适配器模式的工作是将一个接口转换成另一个；
（2）装饰者模式是对包装的对象的行为和责任进行扩展；

// 已存在的、具有特殊功能、但不符合我们既有的标准接口的类
class Adaptee {
    public void specificRequest() {
        System.out.println("被适配类 具有特殊功能...");
    }
}

// 目标接口，或称为标准接口
interface Target {
    public void request();
}

// 具体目标类，只提供普通功能
class ConcreteTarget implements Target {
    public void request() {
        System.out.println("普通类 具有普通功能...");
    }
}

// 适配器类，继承了被适配类，同时实现标准接口
class Adapter extends Adaptee implements Target{
    public void request() {
        super.specificRequest();
    }
}

// 测试类
public class Client {
    public static void main(String[] args) {
        // 使用普通功能类
        Target concreteTarget = new ConcreteTarget();//实例化一个普通类
        concreteTarget.request();

        // 使用特殊功能类，即适配类
        Target adapter = new Adapter();
        adapter.request();
    }
}

Duck与Turkey适配器实例

package AdapterPattern;

import java.util.Random;

//接口
interface Duck {
    void quack();

    void fly();
}

interface Turkey {
    void gobble();

    void fly();
}
interface Drone{
    void beep();
    void spin_rotors();
    void take_off();
}

//类
class MallarDuck implements Duck {
    @Override
    public void quack() {
        System.out.println("Quack");
    }
    @Override
    public void fly() {
        System.out.println("I'm flying.");
    }
}

class WildTurkey implements Turkey {
    @Override
    public void gobble() {
        System.out.println("Gobble gobble");
    }
    @Override
    public void fly() {
        System.out.println("I'm flying a short distance.");
    }
}

class SuperDrone implements Drone{
    @Override
    public void beep(){
        System.out.println("Beep bepp beep");
    }
    @Override
    public void spin_rotors(){
        System.out.println("Rotors are spinning.");
    }
    @Override
    public void take_off(){
        System.out.println("Taking off.");
    }
}

//适配器类
class DuckAdapter implements Turkey {
    Duck duck;
    Random rand;

    public DuckAdapter(Duck duck) {
        this.duck = duck;
        rand = new Random();
    }
    @Override
    public void gobble() {
        duck.quack();
    }
    @Override
    public void fly() {
        if (rand.nextInt(5) == 0) {
            duck.fly();
        }
    }
}

class TurkeyAdapter implements Duck{
    Turkey turkey;

    public TurkeyAdapter(Turkey turkey){
        this.turkey = turkey;
    }
    @Override
    public void quack(){
        turkey.gobble();
    }
    @Override
    public void fly(){
        for(int i=0;i<5;i++){
            turkey.fly();
        }
    }
}

class DroneAdapter implements Duck{
    Drone drone;
    public DroneAdapter(Drone drone){
        this.drone = drone;
    }

    @Override
    public void quack() {
        drone.beep();
    }

    @Override
    public void fly() {
        drone.spin_rotors();
        drone.take_off();
    }
}

public class DuckTestDrive {
    public static void main(String[] args){
        Duck duck = new MallarDuck();

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

        System.out.println("The Turkey says...");
        turkey.gobble();
        turkey.fly();

        System.out.println("\nThe Duck says...");
        testDuck(duck);

        System.out.println("\nThe TurkeyAdapter says...");
        testDuck(turkeyAdapter);

        Drone drone = new SuperDrone();
        Duck droneAdapter = new DroneAdapter(drone);
        testDuck(droneAdapter);

        MallarDuck duck1 = new MallarDuck();
        Turkey duckAdapter = new DuckAdapter(duck1);

        for(int i=0;i<10;i++){
            System.out.println("The DuckAdapter says...");
            duckAdapter.gobble();
            duckAdapter.fly();
        }
    }

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

迭代器适配器实例

package AdapterPattern;

import java.security.PublicKey;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Vector;

class EnumerationIterator implements Iterator<Object>{
    Enumeration<?> enumeration;

    public EnumerationIterator(Enumeration<?> enumeration){
        this.enumeration = enumeration;
    }
    @Override
    public boolean hasNext(){
        return enumeration.hasMoreElements();
    }
    @Override
    public Object next(){
        return enumeration.nextElement();
    }

    @Override
    public void remove() {
        throw new UnsupportedOperationException();
    }
}

class IteratorEnumeration implements Enumeration<Object>{
    Iterator<?> iterator;

    public IteratorEnumeration(Iterator<?> iterator){
        this.iterator = iterator;
    }

    @Override
    public boolean hasMoreElements() {
        return iterator.hasNext();
    }

    @Override
    public Object nextElement() {
        return iterator.next();
    }
}
public class IterEnumTestDrive {
    public static void main(String[] arg){
        String[] args = {"a","b","c","d","e"};
        //Iterator and Enumeration example
        Vector<String> v= new Vector<>(Arrays.asList(args));
        Enumeration<String> enumeration = v.elements();
        while(enumeration.hasMoreElements()){
            System.out.println(enumeration.nextElement());
        }
        Iterator<String> iterator = v.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        //EnumerationAdapter
        Iterator<?> iterator1 = new EnumerationIterator(v.elements());
        while(iterator1.hasNext()){
            System.out.println(iterator1.next());
        }

        //IteratorAdapter
        Enumeration<?> enumeration1 = new IteratorEnumeration(v.iterator());
        while(enumeration1.hasMoreElements()) {
            System.out.println(enumeration1.nextElement());
        }
    }
}

外观模式

定义：外观模式提供了一个统一的接口，用来访问子系统中的一群接口。外观定义了一个高层接口，让子系统更容易使用。

外观模式与适配器模式的区别
1.外观模式不止简化了接口，也将客户从组件的子系统中解耦；
2.外观和适配器可以包装许多类，但是外观的意图是简化接口，而适配器的意图是将接口转换成不同接口。

家庭影院外观模式实例

package FacadePattern;

import javax.swing.plaf.synth.SynthTextAreaUI;

class TheaterLights{
    String description;

    public TheaterLights(String description){
        this.description = description;
    }

    public void on(){
        System.out.println(description + " on");
    }

    public void off(){
        System.out.println(description + " off");
    }

    public void dim(int level){
        System.out.println(description + " dimming to " + level);
    }

    public String toString(){
        return description;
    }
}

class Screen{
    String description;

    public Screen(String description){
        this.description = description;
    }

    public void up(){
        System.out.println(description + " going up");
    }

    public void down(){
        System.out.println(description + " going down");
    }

    public String toString(){
        return description;
    }
}

class PopcornPopper{
    String description;

    public PopcornPopper(String description){
        this.description = description;
    }

    public void on(){
        System.out.println(description + " on");
    }

    public void off(){
        System.out.println(description + " off");
    }

    public void pop(){
        System.out.println(description + " popping popcorn!");
    }

    public String toString(){
        return description;
    }
}

class Amplifier{
    String description;
    Tuner tuner;
    StreamingPlayer player;

    public Amplifier(String description){
        this.description = description;
    }

    public void on(){
        System.out.println(description + " on");
    }

    public void off(){
        System.out.println(description + " off");
    }

    public void setStereoSound(){
        System.out.println(description + " stereo mode on");
    }

    public void setSurroundSound(){
        System.out.println(description + " surround sound on (5 speakers, 1 subwoofer)");
    }

    public void setVolume(int level){
        System.out.println(description + " setting volume to " + level);
    }

    public void setTuner(Tuner tuner){
        System.out.println(description + " setting tuner to " + player);
        this.tuner = tuner;
    }

    public void setStreamingPlayer(StreamingPlayer player){
        System.out.println(description + " setting Streaming player to " + player);
        this.player = player;
    }

    public String toString(){
        return  description;
    }
}

class Tuner{
    String description;
    Amplifier amplifier;
    double frequency;

    public Tuner(String description, Amplifier amplifier){
        this.description = description;
    }

    public void on(){
        System.out.println(description + " on");
    }

    public void off(){
        System.out.println(description + " off");
    }

    public void setFrequency(double frequency){
        System.out.println(description + " setting frequency to " + frequency);
        this.frequency = frequency;
    }

    public void setAm(){
        System.out.println(description + " setting AM mode");
    }

    public void setFm(){
        System.out.println(description + " setting FM mode");
    }

    public String toString(){
        return description;
    }
}

class StreamingPlayer{
    String description;
    int currentChapter;
    Amplifier amplifier;
    String movie;

    public StreamingPlayer(String description, Amplifier amplifier) {
        this.description = description;
        this.amplifier = amplifier;
    }

    public void on() {
        System.out.println(description + " on");
    }

    public void off() {
        System.out.println(description + " off");
    }

    public void play(String movie) {
        this.movie = movie;
        currentChapter = 0;
        System.out.println(description + " playing \"" + movie + "\"");
    }

    public void play(int chapter) {
        if (movie == null) {
            System.out.println(description + " can't play chapter " + chapter + " no movie selected");
        } else {
            currentChapter = chapter;
            System.out.println(description + " playing chapter " + currentChapter + " of \"" + movie + "\"");
        }
    }

    public void stop() {
        currentChapter = 0;
        System.out.println(description + " stopped \"" + movie + "\"");
    }

    public void pause() {
        System.out.println(description + " paused \"" + movie + "\"");
    }

    public void setTwoChannelAudio() {
        System.out.println(description + " set two channel audio");
    }

    public void setSurroundAudio() {
        System.out.println(description + " set surround audio");
    }

    public String toString() {
        return description;
    }
}

class Projector {
    String description;
    StreamingPlayer player;

    public Projector(String description, StreamingPlayer player) {
        this.description = description;
        this.player = player;
    }

    public void on() {
        System.out.println(description + " on");
    }

    public void off() {
        System.out.println(description + " off");
    }

    public void wideScreenMode() {
        System.out.println(description + " in widescreen mode (16x9 aspect ratio)");
    }

    public void tvMode() {
        System.out.println(description + " in tv mode (4x3 aspect ratio)");
    }

    public String toString() {
        return description;
    }
}

class CdPlayer {
    String description;
    int currentTrack;
    Amplifier amplifier;
    String title;

    public CdPlayer(String description, Amplifier amplifier) {
        this.description = description;
        this.amplifier = amplifier;
    }

    public void on() {
        System.out.println(description + " on");
    }

    public void off() {
        System.out.println(description + " off");
    }

    public void eject() {
        title = null;
        System.out.println(description + " eject");
    }

    public void play(String title) {
        this.title = title;
        currentTrack = 0;
        System.out.println(description + " playing \"" + title + "\"");
    }

    public void play(int track) {
        if (title == null) {
            System.out.println(description + " can't play track " + currentTrack +
                    ", no cd inserted");
        } else {
            currentTrack = track;
            System.out.println(description + " playing track " + currentTrack);
        }
    }

    public void stop() {
        currentTrack = 0;
        System.out.println(description + " stopped");
    }

    public void pause() {
        System.out.println(description + " paused \"" + title + "\"");
    }

    public String toString() {
        return description;
    }
}

class HomeTheaterFacade{
    Amplifier amplifier;
    Tuner tuner;
    StreamingPlayer streamingPlayer;
    CdPlayer cdPlayer;
    Projector projector;
    TheaterLights  theaterLights;
    Screen screen;
    PopcornPopper popcornPopper;

    public HomeTheaterFacade(Amplifier amplifier,
                             Tuner tuner,
                             StreamingPlayer streamingPlayer,
                             Projector projector,
                             Screen screen,
                             TheaterLights theaterLights,
                             PopcornPopper popcornPopper){
        this.amplifier = amplifier;
        this.tuner = tuner;
        this.streamingPlayer = streamingPlayer;
        this.projector = projector;
        this.screen = screen;
        this.theaterLights = theaterLights;
        this.popcornPopper = popcornPopper;
    }

    public void watchMoview(String movie){
        System.out.println("Get ready to watch a movie...");
        popcornPopper.on();
        popcornPopper.pop();
        theaterLights.dim(10);
        screen.down();
        projector.on();
        projector.wideScreenMode();
        amplifier.on();
        amplifier.setStreamingPlayer(streamingPlayer);
        amplifier.setSurroundSound();
        amplifier.setVolume(5);
        streamingPlayer.on();
        streamingPlayer.play(movie);
    }

    public void endMovie(){
        System.out.println("Shutting moview theater down...");
        popcornPopper.off();
        theaterLights.on();
        screen.up();
        projector.off();
        amplifier.off();
        streamingPlayer.stop();
        streamingPlayer.off();
    }

    public void listenToRadio(double frequency){
        System.out.println("Tuning in the airwaves...");
        tuner.on();
        tuner.setFrequency(frequency);
        amplifier.on();
        amplifier.setVolume(5);
        amplifier.setTuner(tuner);
    }

    public void endRadio(){
        System.out.println("Shutting down the tuner...");
        tuner.off();
        amplifier.off();
    }
}
public class HomeTheaterTestDrive {
    public static void main(String[] args){
        Amplifier amp = new Amplifier("Top-O-Line Amplifier");
        Tuner tuner = new Tuner("Top-O-Line AM/FM  Tune", amp);
        StreamingPlayer streamingPlayer = new StreamingPlayer("Top-O-Line StreamingPlayer", amp);
        CdPlayer cdPlayer = new CdPlayer("Top-O-Line CD Player", amp);
        Projector projector = new Projector("Top-O-Line Projector", streamingPlayer);
        TheaterLights theaterLights = new TheaterLights("Theater Ceiling Lights");
        Screen screen = new Screen("Theater Screen");
        PopcornPopper popcornPopper = new PopcornPopper("Popcorn Popper");

        HomeTheaterFacade homeTheaterFacade = new HomeTheaterFacade(amp, tuner,streamingPlayer,projector,screen,theaterLights,popcornPopper);
        homeTheaterFacade.watchMoview("Raiders of the Lost Ark");
        homeTheaterFacade.endMovie();
    }
}

模板方法模式

定义：模板方法模式在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。

饮料冲泡法实例

（1）考虑两种饮料，咖啡和茶，二者冲泡方法：
①咖啡：a.把水煮沸；b.用沸水冲泡咖啡；c.把咖啡倒进被子；d.加糖和牛奶。
②茶：a.把水煮沸；b.用沸水浸泡茶叶；c.把茶倒进被子；d.加柠檬。
（2）可以发现二者有些类似，可以将相同的部分封装成抽象类，其他需要改变的方法通过子类实现；

（3）更进一步，将采用相同的prepare方法：

package TemplateMethod.SimpleBarista;

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");
    }
}

class Coffee{
    void prepareRecipe(){
        boilWater();
        brewCoffeeGrinds();
        pourInCup();
        addSugarAndMilk();
    }

    public void boilWater(){
        System.out.println("Boiling 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 SimpleBaristaDrive {
    public static void main(String[] args){
        Tea tea = new Tea();
        Coffee coffee = new Coffee();
        System.out.println("Making tea...");
        tea.prepareRecipe();
        System.out.println("Making coffee...");
        coffee.prepareRecipe();
    }
}

模板方法挂钩

钩子是一种被声明在抽象类中的方法，但只有空的或者默认的实现。钩子的存在，可以让子类有能力对算法的不同点进行挂钩。要不要挂钩，由子类自行决定。

1.何时使用抽象方法，何时使用钩子
当子类“必须”提供算法中某个方法或步骤的实现时，就应当使用抽象方法；
如果算法的这个部分是“可选的”，就用钩子。子类可以选择实现这个钩子，但并不强制这么做。
2.使用钩子真正的目的是什么？
①钩子可以让子类实现算法中的可选部分，或者再钩子对于子类的实现并不重要的时候，子类可以对此钩子置之不理。
②钩子的另一个用法，是让子类能够有机会对模板方法中的某些即将发生的（或刚刚发生的）步骤作出反应。（例如在屏幕上重新显示数据）
3. 抽象方法的数目越少越好
让算法内的步骤不要切割得太细，但是如果步骤太少的话，会比较没有弹性，所以要看情况折衷。—— 某些步骤是可选的，也可以将这些步骤实现成钩子，而不是实现成抽象方法，这样就可以让抽象类的子类负荷减轻。

package TemplateMethod.Barista;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

//抽象类 模板方法
abstract class CaffeineBeverage {

    final void prepareRecipe() {
        boilWater();
        brew();
        pourInCup();
        addCondiments();
    }

    abstract void brew();

    abstract void addCondiments();

    void boilWater() {
        System.out.println("Boiling water");
    }

    void pourInCup() {
        System.out.println("Pouring into cup");
    }
}

//抽象类 模板方法带钩子
abstract class CaffeineBeverageWithHook{
    final void prepareRecipe(){
        boilWater();
        brew();
        pourInCup();
        if(customerWantsCondiments()){
            addCondiments();
        }
    }

    abstract void brew();
    abstract void addCondiments();

    void boilWater(){
        System.out.println("Boiling water");
    }

    void pourInCup(){
        System.out.println("Pouring into cup");
    }

    boolean customerWantsCondiments(){
        return true;
    }
}

class Tea extends CaffeineBeverage {
    @Override
    public void brew() {
        System.out.println("Steeping the tea");
    }

    @Override
    public void addCondiments() {
        System.out.println("Adding Lemon");
    }
}

class Coffee extends CaffeineBeverage{
    public void brew(){
        System.out.println("Dripping Coffee through filter");
    }

    public void addCondiments(){
        System.out.println("Adding Sugar and Milk");
    }
}

class TeaWithHook extends CaffeineBeverageWithHook{
    @Override
    public void brew() {
        System.out.println("Steeping the tea");
    }

    @Override
    public void addCondiments(){
        System.out.println("Adding Lemon");
    }

    @Override
    public  boolean customerWantsCondiments() {
        String answer = getUserInput();
        if(answer.toLowerCase().startsWith("y")) return true;
        else return false;
    }

    private String getUserInput(){
        String answer = null;

        System.out.println("Would you like lemon with your tea (y/n)?");

        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

        try{
            answer = in.readLine();
        }catch (IOException e){
            System.err.println("IO error trying to read your answer");
        }
        if(answer == null){
            return "no";
        }
        return answer;
    }
}

class CoffeeWithHook extends CaffeineBeverageWithHook{
    @Override
    public void brew() {
        System.out.println("Dripping Coffee through filter");
    }

    @Override
    public void addCondiments() {
        System.out.println("Adding Sugar and Milk");
    }

    @Override
    public boolean customerWantsCondiments() {
        String answer = getUserInput();
        if(answer.toLowerCase().startsWith("y")) return true;
        else return false;
    }

    private String getUserInput(){
        String answer = null;

        System.out.println("Would you like milk and sugar with your coffee (y/n)?");

        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        try{
            answer = in.readLine();
        }catch (IOException e){
            System.err.println("IO error trying to read your answer");
        }
        if(answer == null) return "no";
        return answer;
    }
}
public class BeverageTestDrive {
    public static void main(String[] args){
        Tea tea = new Tea();
        Coffee coffee = new Coffee();

        System.out.println("\nMaking tea...");
        tea.prepareRecipe();

        System.out.println("\nMaking coffee...");
        coffee.prepareRecipe();

        TeaWithHook teaWithHook = new TeaWithHook();
        CoffeeWithHook coffeeWithHook = new CoffeeWithHook();

        System.out.println("\nMaking tea...");
        teaWithHook.prepareRecipe();

        System.out.println("\nMaking coffee...");
        coffeeWithHook.prepareRecipe();
    }
}

JDK中Sort的模板方法模式

（1）实际的模板方法模式并非总是如同教科书例子一般得中规中矩，为了负荷当前的环境和实现的约束，它们总是要被适当地修改。
（2）与策略模式在某种程度上类似，但在策略模式中，所组合的类实现了整个算法。数组所实现的排序算法并不完整，它需要一个类填补compareTo()方法的实现。因此，认为这更像模板方法。

JDK的Sort源码

分析：
（1）可以看到整个排序采用二路归并排序，不过为了排序稳定以及速度，长度小于等于7的进行插入排序，而后将前后两部分排好序的进行合并（如果已经整体有序又可以直接优化）；
（2）针对部分排序，即{fromIdx, toIdx}这一部分进行排序时，只复制了这一范围内的数据作为src，而源数组可能会更长！所以用了off偏置，每次交替src和dest的位置！！所以-off表示也要交替！很巧妙，避免多开空间！。
（3）另外还有通过函数式接口Comparator进行比较，而不需要类实现Comparable接口，更加方便。

/**
 * Sorts the specified array of objects into ascending order, according
 * to the {@linkplain Comparable natural ordering} of its elements.
 * All elements in the array must implement the {@link Comparable}
 * interface.  Furthermore, all elements in the array must be
 * <i>mutually comparable</i> (that is, {@code e1.compareTo(e2)} must
 * not throw a {@code ClassCastException} for any elements {@code e1}
 * and {@code e2} in the array).
 *
 * <p>This sort is guaranteed to be <i>stable</i>:  equal elements will
 * not be reordered as a result of the sort.
 *
 * <p>Implementation note: This implementation is a stable, adaptive,
 * iterative mergesort that requires far fewer than n lg(n) comparisons
 * when the input array is partially sorted, while offering the
 * performance of a traditional mergesort when the input array is
 * randomly ordered.  If the input array is nearly sorted, the
 * implementation requires approximately n comparisons.  Temporary
 * storage requirements vary from a small constant for nearly sorted
 * input arrays to n/2 object references for randomly ordered input
 * arrays.
 *
 * <p>The implementation takes equal advantage of ascending and
 * descending order in its input array, and can take advantage of
 * ascending and descending order in different parts of the same
 * input array.  It is well-suited to merging two or more sorted arrays:
 * simply concatenate the arrays and sort the resulting array.
 *
 * <p>The implementation was adapted from Tim Peters's list sort for Python
 * (<a href="http://svn.python.org/projects/python/trunk/Objects/listsort.txt">
 * TimSort</a>).  It uses techniques from Peter McIlroy's "Optimistic
 * Sorting and Information Theoretic Complexity", in Proceedings of the
 * Fourth Annual ACM-SIAM Symposium on Discrete Algorithms, pp 467-474,
 * January 1993.
 *
 * @param a the array to be sorted
 * @throws ClassCastException if the array contains elements that are not
 *         <i>mutually comparable</i> (for example, strings and integers)
 * @throws IllegalArgumentException (optional) if the natural
 *         ordering of the array elements is found to violate the
 *         {@link Comparable} contract
 */
public static void sort(Object[] a) {
    if (LegacyMergeSort.userRequested)
        legacyMergeSort(a);
    else
        ComparableTimSort.sort(a, 0, a.length, null, 0, 0);
}

/**
 * Sorts the specified range of the specified array of objects into
 * ascending order, according to the
 * {@linkplain Comparable natural ordering} of its
 * elements.  The range to be sorted extends from index
 * {@code fromIndex}, inclusive, to index {@code toIndex}, exclusive.
 * (If {@code fromIndex==toIndex}, the range to be sorted is empty.)  All
 * elements in this range must implement the {@link Comparable}
 * interface.  Furthermore, all elements in this range must be <i>mutually
 * comparable</i> (that is, {@code e1.compareTo(e2)} must not throw a
 * {@code ClassCastException} for any elements {@code e1} and
 * {@code e2} in the array).
 *
 * <p>This sort is guaranteed to be <i>stable</i>:  equal elements will
 * not be reordered as a result of the sort.
 *
 * <p>Implementation note: This implementation is a stable, adaptive,
 * iterative mergesort that requires far fewer than n lg(n) comparisons
 * when the input array is partially sorted, while offering the
 * performance of a traditional mergesort when the input array is
 * randomly ordered.  If the input array is nearly sorted, the
 * implementation requires approximately n comparisons.  Temporary
 * storage requirements vary from a small constant for nearly sorted
 * input arrays to n/2 object references for randomly ordered input
 * arrays.
 *
 * <p>The implementation takes equal advantage of ascending and
 * descending order in its input array, and can take advantage of
 * ascending and descending order in different parts of the same
 * input array.  It is well-suited to merging two or more sorted arrays:
 * simply concatenate the arrays and sort the resulting array.
 *
 * <p>The implementation was adapted from Tim Peters's list sort for Python
 * (<a href="http://svn.python.org/projects/python/trunk/Objects/listsort.txt">
 * TimSort</a>).  It uses techniques from Peter McIlroy's "Optimistic
 * Sorting and Information Theoretic Complexity", in Proceedings of the
 * Fourth Annual ACM-SIAM Symposium on Discrete Algorithms, pp 467-474,
 * January 1993.
 *
 * @param a the array to be sorted
 * @param fromIndex the index of the first element (inclusive) to be
 *        sorted
 * @param toIndex the index of the last element (exclusive) to be sorted
 * @throws IllegalArgumentException if {@code fromIndex > toIndex} or
 *         (optional) if the natural ordering of the array elements is
 *         found to violate the {@link Comparable} contract
 * @throws ArrayIndexOutOfBoundsException if {@code fromIndex < 0} or
 *         {@code toIndex > a.length}
 * @throws ClassCastException if the array contains elements that are
 *         not <i>mutually comparable</i> (for example, strings and
 *         integers).
 */
public static void sort(Object[] a, int fromIndex, int toIndex) {
    rangeCheck(a.length, fromIndex, toIndex);
    if (LegacyMergeSort.userRequested)
        legacyMergeSort(a, fromIndex, toIndex);
    else
        ComparableTimSort.sort(a, fromIndex, toIndex, null, 0, 0);
}
/** To be removed in a future release. */
private static void legacyMergeSort(Object[] a,
                                    int fromIndex, int toIndex) {
    Object[] aux = copyOfRange(a, fromIndex, toIndex);
    mergeSort(aux, a, fromIndex, toIndex, -fromIndex);
}
/**
     * Sorts the specified range of the specified array of objects into
     * ascending order, according to the
     * {@linkplain Comparable natural ordering} of its
     * elements.  The range to be sorted extends from index
     * {@code fromIndex}, inclusive, to index {@code toIndex}, exclusive.
     * (If {@code fromIndex==toIndex}, the range to be sorted is empty.)  All
     * elements in this range must implement the {@link Comparable}
     * interface.  Furthermore, all elements in this range must be <i>mutually
     * comparable</i> (that is, {@code e1.compareTo(e2)} must not throw a
     * {@code ClassCastException} for any elements {@code e1} and
     * {@code e2} in the array).
     *
     * <p>This sort is guaranteed to be <i>stable</i>:  equal elements will
     * not be reordered as a result of the sort.
     *
     * <p>Implementation note: This implementation is a stable, adaptive,
     * iterative mergesort that requires far fewer than n lg(n) comparisons
     * when the input array is partially sorted, while offering the
     * performance of a traditional mergesort when the input array is
     * randomly ordered.  If the input array is nearly sorted, the
     * implementation requires approximately n comparisons.  Temporary
     * storage requirements vary from a small constant for nearly sorted
     * input arrays to n/2 object references for randomly ordered input
     * arrays.
     *
     * <p>The implementation takes equal advantage of ascending and
     * descending order in its input array, and can take advantage of
     * ascending and descending order in different parts of the same
     * input array.  It is well-suited to merging two or more sorted arrays:
     * simply concatenate the arrays and sort the resulting array.
     *
     * <p>The implementation was adapted from Tim Peters's list sort for Python
     * (<a href="http://svn.python.org/projects/python/trunk/Objects/listsort.txt">
     * TimSort</a>).  It uses techniques from Peter McIlroy's "Optimistic
     * Sorting and Information Theoretic Complexity", in Proceedings of the
     * Fourth Annual ACM-SIAM Symposium on Discrete Algorithms, pp 467-474,
     * January 1993.
     *
     * @param a the array to be sorted
     * @param fromIndex the index of the first element (inclusive) to be
     *        sorted
     * @param toIndex the index of the last element (exclusive) to be sorted
     * @throws IllegalArgumentException if {@code fromIndex > toIndex} or
     *         (optional) if the natural ordering of the array elements is
     *         found to violate the {@link Comparable} contract
     * @throws ArrayIndexOutOfBoundsException if {@code fromIndex < 0} or
     *         {@code toIndex > a.length}
     * @throws ClassCastException if the array contains elements that are
     *         not <i>mutually comparable</i> (for example, strings and
     *         integers).
     */
    public static void sort(Object[] a, int fromIndex, int toIndex) {
        rangeCheck(a.length, fromIndex, toIndex);
        if (LegacyMergeSort.userRequested)
            legacyMergeSort(a, fromIndex, toIndex);
        else
            ComparableTimSort.sort(a, fromIndex, toIndex, null, 0, 0);
    }

    /** To be removed in a future release. */
    private static void legacyMergeSort(Object[] a,
                                        int fromIndex, int toIndex) {
        Object[] aux = copyOfRange(a, fromIndex, toIndex);
        mergeSort(aux, a, fromIndex, toIndex, -fromIndex);
    }

    /**
     * Tuning parameter: list size at or below which insertion sort will be
     * used in preference to mergesort.
     * To be removed in a future release.
     */
    private static final int INSERTIONSORT_THRESHOLD = 7;

    /**
     * Src is the source array that starts at index 0
     * Dest is the (possibly larger) array destination with a possible offset
     * low is the index in dest to start sorting
     * high is the end index in dest to end sorting
     * off is the offset to generate corresponding low, high in src
     * To be removed in a future release.
     */
    @SuppressWarnings({"unchecked", "rawtypes"})
    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++];
        }
    }

    /**
     * Swaps x[a] with x[b].
     */
    private static void swap(Object[] x, int a, int b) {
        Object t = x[a];
        x[a] = x[b];
        x[b] = t;
    }
    /**
     * Sorts the specified array of objects according to the order induced by
     * the specified comparator.  All elements in the array must be
     * <i>mutually comparable</i> by the specified comparator (that is,
     * {@code c.compare(e1, e2)} must not throw a {@code ClassCastException}
     * for any elements {@code e1} and {@code e2} in the array).
     *
     * <p>This sort is guaranteed to be <i>stable</i>:  equal elements will
     * not be reordered as a result of the sort.
     *
     * <p>Implementation note: This implementation is a stable, adaptive,
     * iterative mergesort that requires far fewer than n lg(n) comparisons
     * when the input array is partially sorted, while offering the
     * performance of a traditional mergesort when the input array is
     * randomly ordered.  If the input array is nearly sorted, the
     * implementation requires approximately n comparisons.  Temporary
     * storage requirements vary from a small constant for nearly sorted
     * input arrays to n/2 object references for randomly ordered input
     * arrays.
     *
     * <p>The implementation takes equal advantage of ascending and
     * descending order in its input array, and can take advantage of
     * ascending and descending order in different parts of the same
     * input array.  It is well-suited to merging two or more sorted arrays:
     * simply concatenate the arrays and sort the resulting array.
     *
     * <p>The implementation was adapted from Tim Peters's list sort for Python
     * (<a href="http://svn.python.org/projects/python/trunk/Objects/listsort.txt">
     * TimSort</a>).  It uses techniques from Peter McIlroy's "Optimistic
     * Sorting and Information Theoretic Complexity", in Proceedings of the
     * Fourth Annual ACM-SIAM Symposium on Discrete Algorithms, pp 467-474,
     * January 1993.
     *
     * @param <T> the class of the objects to be sorted
     * @param a the array to be sorted
     * @param c the comparator to determine the order of the array.  A
     *        {@code null} value indicates that the elements'
     *        {@linkplain Comparable natural ordering} should be used.
     * @throws ClassCastException if the array contains elements that are
     *         not <i>mutually comparable</i> using the specified comparator
     * @throws IllegalArgumentException (optional) if the comparator is
     *         found to violate the {@link Comparator} contract
     */
    public static <T> void sort(T[] a, Comparator<? super T> c) {
        if (c == null) {
            sort(a);
        } else {
            if (LegacyMergeSort.userRequested)
                legacyMergeSort(a, c);
            else
                TimSort.sort(a, 0, a.length, c, null, 0, 0);
        }
    }

    /** To be removed in a future release. */
    private static <T> void legacyMergeSort(T[] a, Comparator<? super T> c) {
        T[] aux = a.clone();
        if (c==null)
            mergeSort(aux, a, 0, a.length, 0);
        else
            mergeSort(aux, a, 0, a.length, 0, c);
    }

    /**
     * Sorts the specified range of the specified array of objects according
     * to the order induced by the specified comparator.  The range to be
     * sorted extends from index {@code fromIndex}, inclusive, to index
     * {@code toIndex}, exclusive.  (If {@code fromIndex==toIndex}, the
     * range to be sorted is empty.)  All elements in the range must be
     * <i>mutually comparable</i> by the specified comparator (that is,
     * {@code c.compare(e1, e2)} must not throw a {@code ClassCastException}
     * for any elements {@code e1} and {@code e2} in the range).
     *
     * <p>This sort is guaranteed to be <i>stable</i>:  equal elements will
     * not be reordered as a result of the sort.
     *
     * <p>Implementation note: This implementation is a stable, adaptive,
     * iterative mergesort that requires far fewer than n lg(n) comparisons
     * when the input array is partially sorted, while offering the
     * performance of a traditional mergesort when the input array is
     * randomly ordered.  If the input array is nearly sorted, the
     * implementation requires approximately n comparisons.  Temporary
     * storage requirements vary from a small constant for nearly sorted
     * input arrays to n/2 object references for randomly ordered input
     * arrays.
     *
     * <p>The implementation takes equal advantage of ascending and
     * descending order in its input array, and can take advantage of
     * ascending and descending order in different parts of the same
     * input array.  It is well-suited to merging two or more sorted arrays:
     * simply concatenate the arrays and sort the resulting array.
     *
     * <p>The implementation was adapted from Tim Peters's list sort for Python
     * (<a href="http://svn.python.org/projects/python/trunk/Objects/listsort.txt">
     * TimSort</a>).  It uses techniques from Peter McIlroy's "Optimistic
     * Sorting and Information Theoretic Complexity", in Proceedings of the
     * Fourth Annual ACM-SIAM Symposium on Discrete Algorithms, pp 467-474,
     * January 1993.
     *
     * @param <T> the class of the objects to be sorted
     * @param a the array to be sorted
     * @param fromIndex the index of the first element (inclusive) to be
     *        sorted
     * @param toIndex the index of the last element (exclusive) to be sorted
     * @param c the comparator to determine the order of the array.  A
     *        {@code null} value indicates that the elements'
     *        {@linkplain Comparable natural ordering} should be used.
     * @throws ClassCastException if the array contains elements that are not
     *         <i>mutually comparable</i> using the specified comparator.
     * @throws IllegalArgumentException if {@code fromIndex > toIndex} or
     *         (optional) if the comparator is found to violate the
     *         {@link Comparator} contract
     * @throws ArrayIndexOutOfBoundsException if {@code fromIndex < 0} or
     *         {@code toIndex > a.length}
     */
    public static <T> void sort(T[] a, int fromIndex, int toIndex,
                                Comparator<? super T> c) {
        if (c == null) {
            sort(a, fromIndex, toIndex);
        } else {
            rangeCheck(a.length, fromIndex, toIndex);
            if (LegacyMergeSort.userRequested)
                legacyMergeSort(a, fromIndex, toIndex, c);
            else
                TimSort.sort(a, fromIndex, toIndex, c, null, 0, 0);
        }
    }

    /** To be removed in a future release. */
    private static <T> void legacyMergeSort(T[] a, int fromIndex, int toIndex,
                                            Comparator<? super T> c) {
        T[] aux = copyOfRange(a, fromIndex, toIndex);
        if (c==null)
            mergeSort(aux, a, fromIndex, toIndex, -fromIndex);
        else
            mergeSort(aux, a, fromIndex, toIndex, -fromIndex, c);
    }

    /**
     * Src is the source array that starts at index 0
     * Dest is the (possibly larger) array destination with a possible offset
     * low is the index in dest to start sorting
     * high is the end index in dest to end sorting
     * off is the offset into src corresponding to low in dest
     * To be removed in a future release.
     */
    @SuppressWarnings({"rawtypes", "unchecked"})
    private static void mergeSort(Object[] src,
                                  Object[] dest,
                                  int low, int high, int off,
                                  Comparator c) {
        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 && c.compare(dest[j-1], 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, c);
        mergeSort(dest, src, mid, high, -off, c);

        // 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 (c.compare(src[mid-1], 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 && c.compare(src[p], src[q]) <= 0)
                dest[i] = src[p++];
            else
                dest[i] = src[q++];
        }
    }

排序实例

package TemplateMethod.sort;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;

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 " + weight;
    }

    @Override
    public int compareTo(Duck other) {
        if (this.weight < other.weight) return -1;
        else if (this.weight == other.weight) return 0;
        else return 1;
    }
}

class Dog {
    String name;
    int weight;

    public Dog(String name, int weight) {
        this.name = name;
        this.weight = weight;
    }

    public String toString() {
        return name + " weights " + weight;
    }
}

public class DuckSortTestDrive {
    public static void main(String[] args) {
        Duck[] ducks = {
                new Duck("Daffy", 8),
                new Duck("Dewey", 2),
                new Duck("Howard", 7),
                new Duck("Louie", 2),
                new Duck("Donald", 10),
                new Duck("Huey", 2)
        };

        System.out.println("Before sorting (Ducks): ");
        display(ducks);

        Arrays.sort(ducks);
        System.out.println("\n After sorting (Ducks): ");
        display(ducks);

        Dog[] dogs = {
                new Dog("Daffy", 8),
                new Dog("Dewey", 2),
                new Dog("Howard", 7),
                new Dog("Louie", 2),
                new Dog("Donald", 10),
                new Dog("Huey", 2)
        };

        System.out.println("\nBefore sorting (Dogs): ");
        displayDog(dogs);

        Arrays.sort(dogs, new Comparator<Dog>() {
            @Override
            public int compare(Dog o1, Dog o2) {
                if (o1.weight < o2.weight) return -1;
                else if (o1.weight == o2.weight) return 0;
                else return 1;
            }
        });
        System.out.println("\nAfter sorting (Dogs): ");
        displayDog(dogs);
    }

    public static void display(Duck[] ducks) {
        for (Duck d : ducks) {
            System.out.println(d);
        }
    }

    public static void displayDog(Dog[] dogs) {
        for (Dog d : dogs) {
            System.out.println(d);
        }
    }
}

Before sorting (Ducks):
Daffy weights 8
Dewey weights 2
Howard weights 7
Louie weights 2
Donald weights 10
Huey weights 2

 After sorting (Ducks):
Dewey weights 2
Louie weights 2
Huey weights 2
Howard weights 7
Daffy weights 8
Donald weights 10

Before sorting (Dogs):
Daffy weights 8
Dewey weights 2
Howard weights 7
Louie weights 2
Donald weights 10
Huey weights 2

After sorting (Dogs):
Dewey weights 2
Louie weights 2
Huey weights 2
Howard weights 7
Daffy weights 8
Donald weights 10

迭代器模式

定义：迭代器模式提供了一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示。

（1）针对不同的集合(collection)类型所造成的遍历进行同一封装；
（2）迭代器模式让我们能游走于聚合内的每一个元素，而又不暴露其内部的表示；
（3）游走的任务放在迭代器上，而不是聚合上。这样简化了聚合的接口和实现，也让责任各得其所。
（3）可以使得类与遍历解耦，可以遍历各种所需的对象组。

菜单Implicit

package IteratorPattern.implicit;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

interface Menu {
    Iterator<MenuItem> createIterator();
}

class MenuItem {
    String name;
    String description;
    boolean vegetarian;
    double price;

    public MenuItem(String name,
                    String description,
                    boolean vegetarian,
                    double price) {
        this.name = name;
        this.description = description;
        this.vegetarian = vegetarian;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public String getDescription() {
        return description;
    }

    public double getPrice() {
        return price;
    }

    public boolean isVegetarian() {
        return vegetarian;
    }
}

class PancakeHouseMenu implements Menu {
    ArrayList<MenuItem> menuItems;

    public PancakeHouseMenu() {
        menuItems = new ArrayList<>();
        addItem("K&B's Pancake Breakfast",
                "Pancakes with scrambled eggs, and toast",
                true,
                2.99);

        addItem("Regular Pancake Breakfast",
                "Pancakes with fried eggs, sausage",
                false,
                2.99);

        addItem("Blueberry Pancakes",
                "Pancakes made with fresh blueberries, and blueberry syrup",
                true,
                3.49);

        addItem("Waffles",
                "Waffles, with your choice of blueberries or strawberries",
                true,
                3.59);
    }

    public void addItem(String name, String description,
                        boolean vegetarian, double price) {
        menuItems.add(new MenuItem(name, description, vegetarian, price));
    }

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

    @Override
    public Iterator<MenuItem> createIterator() {
        return menuItems.iterator();
    }

    // other menu methods here
}

class DinerMenu implements Menu {
    static final int MAX_ITEMS = 6;
    int numberOfItems = 0;
    MenuItem[] menuItems;

    public DinerMenu() {
        menuItems = new MenuItem[MAX_ITEMS];

        addItem("Vegetarian BLT",
                "(Fakin') Bacon with lettuce & tomato on whole wheat", true, 2.99);
        addItem("BLT",
                "Bacon with lettuce & tomato on whole wheat", false, 2.99);
        addItem("Soup of the day",
                "Soup of the day, with a side of potato salad", false, 3.29);
        addItem("Hotdog",
                "A hot dog, with saurkraut, relish, onions, topped with cheese",
                false, 3.05);
        addItem("Steamed Veggies and Brown Rice",
                "Steamed vegetables over brown rice", true, 3.99);
        addItem("Pasta",
                "Spaghetti with Marinara Sauce, and a slice of sourdough bread",
                true, 3.89);
    }

    public void addItem(String name, String description,
                        boolean vegetarian, double price) {
        MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
        if (numberOfItems >= MAX_ITEMS) {
            System.err.println("Sorry, menu is full! Can't add item to menu");
        } else {
            menuItems[numberOfItems] = menuItem;
            numberOfItems++;
        }
    }

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

    @Override
    public Iterator<MenuItem> createIterator() {
        return new DinerMenuIterator(menuItems);
    }

    // other menu methods here
}

class DinerMenuIterator implements Iterator<MenuItem> {
    MenuItem[] list;
    int position = 0;

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

    @Override
    public MenuItem next() {
        return list[position++];
    }

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

    @Override
    public void remove() {
        if (position <= 0) {
            throw new IllegalStateException("You can't remove an iterm until you've done at least one next()");
        }

        if(list[position-1] != null){
            for(int i=position-1;i<list.length-1;i++){
                list[i] = list[i+1];
            }
            list[list.length-1] = null;
        }
    }
}

class Waitress{
    Menu pancakeHouseMenu;
    Menu dinerMenu;

    public Waitress(Menu pancakeHouseMenu, Menu dinerMenu){
        this.pancakeHouseMenu = pancakeHouseMenu;
        this.dinerMenu = dinerMenu;
    }

    // implicit iteration
    public void printMenu(){
        List<MenuItem> breakfastItems = ((PancakeHouseMenu) pancakeHouseMenu).getMenuItems();
        for(MenuItem m : breakfastItems){
            printMenuItem(m);
        }

        System.out.println(" - - - - - - - - ");

        MenuItem[] lunchItems = ((DinerMenu) dinerMenu).getMenuItems();
        for(MenuItem m : lunchItems){
            printMenuItem(m);
        }
    }

    public void printMenuItem(MenuItem menuItem){
        System.out.print(menuItem.getName() + ", ");
        System.out.print(menuItem.getPrice() + " -- ");
        System.out.println(menuItem.getDescription());
    }
}

class WaitressWithIterator{
    ArrayList<Menu> menus;

    public WaitressWithIterator(ArrayList<Menu> menus){
        this.menus = menus;
    }

    public void printMenu(){
        Iterator<?> menuIterator = menus.iterator();
        while(menuIterator.hasNext()){
            Menu menu = (Menu) menuIterator.next();
            printMenu(menu.createIterator());
            System.out.println(" - - - - - - - - ");
        }
    }

    void printMenu(Iterator<?> iterator){
        while(iterator.hasNext()){
            MenuItem menuItem = (MenuItem) iterator.next();
            System.out.print(menuItem.getName() + ", ");
            System.out.print(menuItem.getPrice() + " -- ");
            System.out.println(menuItem.getDescription());
        }
    }
}
public class MenuTestDrive {
    public static void main(String args[]){
        PancakeHouseMenu pancakeHouseMenu = new PancakeHouseMenu();
        DinerMenu dinerMenu = new DinerMenu();

        Waitress waitress = new Waitress(pancakeHouseMenu, dinerMenu);
        // Use implicit iteration
        waitress.printMenu();

        System.out.println(" - - - - - - - - ");

        ArrayList<Menu> menus = new ArrayList<>();
        menus.add(pancakeHouseMenu);
        menus.add(dinerMenu);
        WaitressWithIterator waitress1 = new WaitressWithIterator(menus);
        waitress1.printMenu();
    }
}

菜单Iterator实例

package IteratorPattern.dinermerger;

import javax.swing.*;
import java.awt.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

interface Iterator {
    boolean hasNext();

    MenuItem next();
}

interface Menu {
    Iterator createIterator();
}

class MenuItem {
    String name;
    String description;
    boolean vegetarian;
    double price;

    public MenuItem(String name,
                    String description,
                    boolean vegetarian,
                    double price) {
        this.name = name;
        this.description = description;
        this.vegetarian = vegetarian;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public String getDescription() {
        return description;
    }

    public double getPrice() {
        return price;
    }

    public boolean isVegetarian() {
        return vegetarian;
    }

    public String toString() {
        return (name + ", $" + price + "\n   " + description);
    }
}

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

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

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

    @Override
    public MenuItem next() {
        return items[position++];
    }
}

class ArrayListIterator implements Iterator {
    ArrayList<MenuItem> items;
    int position = 0;

    public ArrayListIterator(ArrayList<MenuItem> items) {
        this.items = items;
    }

    @Override
    public boolean hasNext() {
        if (position >= items.size()) {
            return false;
        } else {
            return true;
        }
    }

    @Override
    public MenuItem next() {
        return items.get(position++);
    }
}

class DinerMenu implements Menu {
    static final int MAX_ITEMS = 6;
    int numberOfItems = 0;
    MenuItem[] menuItems;

    public DinerMenu() {
        menuItems = new MenuItem[MAX_ITEMS];
        addItem("Vegetarian BLT",
                "(Fakin') Bacon with lettuce & tomato on whole wheat", true, 2.99);
        addItem("BLT",
                "Bacon with lettuce & tomato on whole wheat", false, 2.99);
        addItem("Soup of the day",
                "Soup of the day, with a side of potato salad", false, 3.29);
        addItem("Hotdog",
                "A hot dog, with sauerkraut, relish, onions, topped with cheese",
                false, 3.05);
        addItem("Steamed Veggies and Brown Rice",
                "Steamed vegetables over brown rice", true, 3.99);
        addItem("Pasta",
                "Spaghetti with Marinara Sauce, and a slice of sourdough bread",
                true, 3.89);
    }

    public void addItem(String name, String description,
                        boolean vegetarian, double price) {
        MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
        if (numberOfItems >= MAX_ITEMS) {
            System.err.println("Sorry, menu is full! Can't add item to menu");
        } else {
            menuItems[numberOfItems++] = menuItem;
        }
    }

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

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

    // other menu methods here
}

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

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

    @Override
    public MenuItem next() {
        return items[position++];
    }

    @Override
    public boolean hasNext() {
        return items.length > position; // no remove method, so do this.
    }
}

class PancakeHouseMenu implements Menu {
    List<MenuItem> menuItems;

    public PancakeHouseMenu() {
        menuItems = new ArrayList<>();
        addItem("K&B's Pancake Breakfast",
                "Pancakes with scrambled eggs, and toast",
                true,
                2.99);

        addItem("Regular Pancake Breakfast",
                "Pancakes with fried eggs, sausage",
                false,
                2.99);

        addItem("Blueberry Pancakes",
                "Pancakes made with fresh blueberries",
                true,
                3.49);

        addItem("Waffles",
                "Waffles, with your choice of blueberries or strawberries",
                true,
                3.59);
    }

    public void addItem(String name, String description,
                        boolean vegetarian, double price) {
        menuItems.add(new MenuItem(name, description, vegetarian, price));
    }

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

    @Override
    public Iterator createIterator() {
        return new PancakeHouseMenuIterator(menuItems);
    }

    public String toString() {
        return "Objectville Pancake House Menu";
    }

    // other menu methods here
}

class PancakeHouseMenuIterator implements Iterator {
    List<MenuItem> items;
    int position = 0;

    public PancakeHouseMenuIterator(List<MenuItem> items) {
        this.items = items;
    }

    @Override
    public MenuItem next() {
        return items.get(position++);
    }

    @Override
    public boolean hasNext() {
        return items.size() > position;
    }
}

class Waitress {
    Menu pancakeHouseMenu;
    Menu dinerMenu;

    public Waitress(Menu pancakeHouseMenu, Menu dinerMenu) {
        this.pancakeHouseMenu = pancakeHouseMenu;
        this.dinerMenu = dinerMenu;
    }

    public void printMenu() {
        Iterator pancakeIterator = pancakeHouseMenu.createIterator();
        Iterator dinerIterator = dinerMenu.createIterator();

        System.out.println("MENU\n----\nBREAKFAST");
        printMenu(pancakeIterator);
        System.out.println("\nLUNCH");
        printMenu(dinerIterator);
    }

    private void printMenu(Iterator iterator) {
        while (iterator.hasNext()) {
            MenuItem menuItem = iterator.next();
            System.out.print(menuItem.getName() + ", ");
            System.out.print(menuItem.getPrice() + " -- ");
            System.out.print(menuItem.getDescription());
        }
    }

    public void printVegetarianMenu() {
        printVegetarianMenu(pancakeHouseMenu.createIterator());
        printVegetarianMenu(dinerMenu.createIterator());
    }

    private void printVegetarianMenu(Iterator iterator) {
        while (iterator.hasNext()) {
            MenuItem menuItem = iterator.next();
            if (menuItem.isVegetarian()) {
                System.out.print(menuItem.getName());
                System.out.println("\t\t" + menuItem.getPrice());
                System.out.println("\t" + menuItem.getDescription());
            }
        }
    }

    public boolean isItemVegetarian(String name) {
        Iterator breakfastIterator = pancakeHouseMenu.createIterator();
        if (isVegetarian(name, breakfastIterator)) {
            return true;
        }
        Iterator dinnerIterator = dinerMenu.createIterator();
        if (isVegetarian(name, dinnerIterator)) {
            return true;
        }
        return false;
    }

    private boolean isVegetarian(String name, Iterator iterator) {
        while (iterator.hasNext()) {
            MenuItem menuItem = iterator.next();
            if (menuItem.getName().equals(name)) {
                if (menuItem.isVegetarian()) return true;
            }
        }
        return false;
    }
}

public class MenuTestDrive {
    public static void main(String args[]) {
        Menu pancakeHouseMenu = new PancakeHouseMenu();
        Menu dinerMenu = new DinerMenu();
        Waitress waitress = new Waitress(pancakeHouseMenu, dinerMenu);

        // With iterators
        waitress.printMenu();

        // Without the Waitress, wee need the code
        printMenus();
    }

    public static void printMenus() {
        PancakeHouseMenu pancakeHouseMenu = new PancakeHouseMenu();
        DinerMenu dinerMenu = new DinerMenu();

        List<MenuItem> breakfastItems = pancakeHouseMenu.getMenuItems();
        MenuItem[] lunchItems = dinerMenu.getMenuItems();

        //print as Iterable
        printMenu(breakfastItems);
        printMenu(Arrays.asList(lunchItems));

        //print with forEach
        System.out.println("=== forEach ===");
        breakfastItems.forEach(item -> System.out.println(item));
        Arrays.asList(lunchItems).forEach(item -> System.out.println(item));
        System.out.println("=== forEach ===");

        //Using enhanced for loop
        System.out.println("USING ENHANCED FOR");
        for (MenuItem menuItem : breakfastItems) {
            System.out.print(menuItem.getName());
            System.out.println("\t\t" + menuItem.getPrice());
            System.out.println("\t" + menuItem.getDescription());
        }

        for (MenuItem menuItem : lunchItems) {
            System.out.print(menuItem.getName());
            System.out.println("\t\t" + menuItem.getPrice());
            System.out.println("\t" + menuItem.getDescription());
        }

        //Exposing implementaion
        System.out.println("USING FOR LOOPS");
        for (int i = 0; i < breakfastItems.size(); i++) {
            MenuItem menuItem = (MenuItem)breakfastItems.get(i);
            System.out.print(menuItem.getName());
            System.out.println("\t\t" + menuItem.getPrice());
            System.out.println("\t" + menuItem.getDescription());
        }

        for (int i = 0; i < lunchItems.length; i++) {
            MenuItem menuItem = lunchItems[i];
            System.out.print(menuItem.getName());
            System.out.println("\t\t" + menuItem.getPrice());
            System.out.println("\t" + menuItem.getDescription());
        }
    }

    public static void printMenu(Iterable<MenuItem> a) {
        for (MenuItem menuItem : a) {
            System.out.print(menuItem.getName());
            System.out.println("\t\t" + menuItem.getPrice());
            System.out.println("\t" + menuItem.getDescription());
        }
    }
}

组合模式

定义：组合模式允许将对象组合成树形结构来表现“整体/部分”层次结构。组合能让客户以一致的方式处理个别对象以及对象组合。

（1）以一致的方式处理 个别对象 以及 对象组合;
（2）大多数情况下，可以忽略对象组合和个别对象之间的差别；
（3）组合模式以单一责任原则换取透明性(transparency)，透明性是通过让组件的接口同时包含一些管理子节点和叶节点的操作，客户就可以将组合和叶节点一视同仁。也就是说，一个元素究竟是组合还是叶节点，对客户是透明的！
（4）客户有机会对一个元素做一些不恰当或没有意义的操作，失去了一些“安全性”；
（5）组件可以有一个指向父亲的指针，以便在游走时更容易；
（6）孩子的次序：万一需要保持特定孩子次序的组合对象，就需要使用更复杂的管理方案来进行孩子的增加和删除，而且当你在这个层次结构内游走时，应该要更加小心；
（7）缓存(caching)：如果组合结构很复杂的，或者遍历的代价太高，那么实现组合节点的缓存就很有帮助。比方说，如果你要不断地遍历一个组合，而且它的每一个子节点都需要进行某些计算，那你就应该使用缓存来临时保存结果，省去遍历的开支。
（8）让客户更简单。客户不再需要操心面对的是组合对象还是叶节点对象了。也就不需要写一大堆if语句来保证他们对正确的对象调用了正确的方法。通常，他们只需要对整个结构调用一个方法并执行操作就可以了。

菜单实例

（1）print()方法递归调用！
（2）叶节点和子节点对用户来讲透明，用户不知道具体细节，保证了安全性。

package CompositePattern.menu;

import java.util.ArrayList;
import java.util.Iterator;

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();
    }
}

class Menu extends MenuComponent {
    ArrayList<MenuComponent> menuComponents = new ArrayList<>();
    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 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("------------------");

        for (MenuComponent menuComponent : menuComponents) {
            menuComponent.print();
        }
    }
}

class MenuItem extends MenuComponent {
    String name;
    String description;
    boolean vegetarian;
    double price;

    public MenuItem(String name,
                    String description,
                    boolean vegetarian,
                    double price) {
        this.name = name;
        this.description = description;
        this.vegetarian = vegetarian;
        this.price = price;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public String getDescription() {
        return description;
    }

    @Override
    public double getPrice() {
        return price;
    }

    @Override
    public boolean isVegetarian() {
        return vegetarian;
    }

    @Override
    public void print() {
        System.out.println("  " + getName());
        if (isVegetarian()) {
            System.out.print("(v)");
        }
        System.out.println(", " + getPrice());
        System.out.println("    -- " + getDescription());
    }
}

class Waitress{
    MenuComponent allMenus;

    public Waitress(MenuComponent allMenus){
        this.allMenus = allMenus;
    }

    public void printMenu(){
        allMenus.print();
    }
}
public class MenuTestDrive {
    public static void main(String[] args){
        MenuComponent pancakeHouseMenu = new Menu("PANCAKE HOUSE MENU", "Breakfast");
        MenuComponent dinerMenu = new Menu("DINER MENU", "Lunch");
        MenuComponent cafeMenu = new Menu("CAFE MENU", "Dinner");
        MenuComponent dessertMenu = new Menu("DESSERT MENU", "Dessert of course!");
        MenuComponent coffeeMenu = new Menu("COFFEE MENU", "Stuff to go with your afternoon coffee");
        MenuComponent allMenus = new Menu("ALL MENUS", "ALLmenus combined");

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

        pancakeHouseMenu.add(new MenuItem(
                "K&B's Pancake Breakfast",
                "Pancakes with scrambled eggs, and toast",
                true,
                2.99));
        pancakeHouseMenu.add(new MenuItem(
                "Regular Pancake Breakfast",
                "Pancakes with fried eggs, sausage",
                false,
                2.99));
        pancakeHouseMenu.add(new MenuItem(
                "Blueberry Pancakes",
                "Pancakes made with fresh blueberries, and blueberry syrup",
                true,
                3.49));
        pancakeHouseMenu.add(new MenuItem(
                "Waffles",
                "Waffles, with your choice of blueberries or strawberries",
                true,
                3.59));

        dinerMenu.add(new MenuItem(
                "Vegetarian BLT",
                "(Fakin') Bacon with lettuce & tomato on whole wheat",
                true,
                2.99));
        dinerMenu.add(new MenuItem(
                "BLT",
                "Bacon with lettuce & tomato on whole wheat",
                false,
                2.99));
        dinerMenu.add(new MenuItem(
                "Soup of the day",
                "A bowl of the soup of the day, with a side of potato salad",
                false,
                3.29));
        dinerMenu.add(new MenuItem(
                "Hotdog",
                "A hot dog, with saurkraut, relish, onions, topped with cheese",
                false,
                3.05));
        dinerMenu.add(new MenuItem(
                "Steamed Veggies and Brown Rice",
                "Steamed vegetables over brown rice",
                true,
                3.99));
        dinerMenu.add(new MenuItem(
                "Pasta",
                "Spaghetti with Marinara Sauce, and a slice of sourdough bread",
                true,
                3.89));

        dinerMenu.add(dessertMenu);

        dessertMenu.add(new MenuItem(
                "Apple Pie",
                "Apple pie with a flakey crust, topped with vanilla icecream",
                true,
                1.59));

        dessertMenu.add(new MenuItem(
                "Cheesecake",
                "Creamy New York cheesecake, with a chocolate graham crust",
                true,
                1.99));
        dessertMenu.add(new MenuItem(
                "Sorbet",
                "A scoop of raspberry and a scoop of lime",
                true,
                1.89));

        cafeMenu.add(new MenuItem(
                "Veggie Burger and Air Fries",
                "Veggie burger on a whole wheat bun, lettuce, tomato, and fries",
                true,
                3.99));
        cafeMenu.add(new MenuItem(
                "Soup of the day",
                "A cup of the soup of the day, with a side salad",
                false,
                3.69));
        cafeMenu.add(new MenuItem(
                "Burrito",
                "A large burrito, with whole pinto beans, salsa, guacamole",
                true,
                4.29));

        cafeMenu.add(coffeeMenu);

        coffeeMenu.add(new MenuItem(
                "Coffee Cake",
                "Crumbly cake topped with cinnamon and walnuts",
                true,
                1.59));
        coffeeMenu.add(new MenuItem(
                "Bagel",
                "Flavors include sesame, poppyseed, cinnamon raisin, pumpkin",
                false,
                0.69));
        coffeeMenu.add(new MenuItem(
                "Biscotti",
                "Three almond or hazelnut biscotti cookies",
                true,
                0.89));

        Waitress waitress = new Waitress(allMenus);
        waitress.printMenu();
    }
}

菜单实例+迭代器

空迭代器：
对于菜单项内没什么可以遍历的，有两种选择：
（1）返回null：可以让createIterator()返回null，如果这么做，需要条件判断语句；
（2）返回一个空迭代器，而这个迭代器的hasNext()永远返回false：这似乎是更好的方案。我们依然可以返回一个迭代器，客户不用再担心返回值是否为null。即创建了一个迭代器，作用是“没作用”，可以是代码统一。

package CompositePattern.MenuIterator;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.Stack;

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();
    }

    public abstract Iterator<MenuComponent> createIterator();
}

class CompositeIterator implements Iterator<MenuComponent>{
    Stack<Iterator<MenuComponent>> stack= new Stack<>();

    public CompositeIterator(Iterator<MenuComponent> iterator){
        stack.push(iterator);
    }

    // 先根遍历！栈实现！
    @Override
    public MenuComponent next() {
        if(hasNext()){
            Iterator<MenuComponent> iterator = stack.peek();
            MenuComponent component = iterator.next();
            stack.push(component.createIterator());
            return component;
        }else return null;
    }

    @Override
    public boolean hasNext() {
        if(stack.empty()) return false;
        else{
            Iterator<MenuComponent> iterator = stack.peek();
            if(!iterator.hasNext()){
                stack.pop();
                return hasNext();
            }else return true;
        }
    }

    /*
    No longer needed as of Java 8
    A default 'remove' method for the interface has been implemented!
     */
    @Override
    public void remove() {
        throw new UnsupportedOperationException();
    }
}

class NullIterator implements Iterator<MenuComponent>{
    @Override
    public MenuComponent next() {
        return null;
    }

    @Override
    public boolean hasNext() {
        return false;
    }

    /*
    No longer needed as of Java 8
    A default 'remove' method of the interface has been implemented!
     */
    @Override
    public void remove() {
        throw new UnsupportedOperationException();
    }
}

class Menu extends MenuComponent {
    Iterator<MenuComponent> iterator = null;
    ArrayList<MenuComponent> menuComponents = new ArrayList<>();
    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 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("------------------");

        for (MenuComponent menuComponent : menuComponents) {
            menuComponent.print();
        }
    }

    @Override
    public Iterator<MenuComponent> createIterator() {
        if(iterator == null){
            iterator = new CompositeIterator(menuComponents.iterator());
        }
        return iterator;
    }
}

class MenuItem extends MenuComponent {
    String name;
    String description;
    boolean vegetarian;
    double price;

    public MenuItem(String name,
                    String description,
                    boolean vegetarian,
                    double price) {
        this.name = name;
        this.description = description;
        this.vegetarian = vegetarian;
        this.price = price;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public String getDescription() {
        return description;
    }

    @Override
    public double getPrice() {
        return price;
    }

    @Override
    public boolean isVegetarian() {
        return vegetarian;
    }

    @Override
    public void print() {
        System.out.println("  " + getName());
        if (isVegetarian()) {
            System.out.print("(v)");
        }
        System.out.println(", " + getPrice());
        System.out.println("    -- " + getDescription());
    }

    @Override
    public Iterator<MenuComponent> createIterator() {
        return new NullIterator();
    }
}

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){}
        }
    }
}
public class MenuTestDrive {
    public static void main(String[] args){
        MenuComponent pancakeHouseMenu =
                new Menu("PANCAKE HOUSE MENU", "Breakfast");
        MenuComponent dinerMenu =
                new Menu("DINER MENU", "Lunch");
        MenuComponent cafeMenu =
                new Menu("CAFE MENU", "Dinner");
        MenuComponent dessertMenu =
                new Menu("DESSERT MENU", "Dessert of course!");

        MenuComponent allMenus = new Menu("ALL MENUS", "All menus combined");

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

        pancakeHouseMenu.add(new MenuItem(
                "K&B's Pancake Breakfast",
                "Pancakes with scrambled eggs, and toast",
                true,
                2.99));
        pancakeHouseMenu.add(new MenuItem(
                "Regular Pancake Breakfast",
                "Pancakes with fried eggs, sausage",
                false,
                2.99));
        pancakeHouseMenu.add(new MenuItem(
                "Blueberry Pancakes",
                "Pancakes made with fresh blueberries, and blueberry syrup",
                true,
                3.49));
        pancakeHouseMenu.add(new MenuItem(
                "Waffles",
                "Waffles, with your choice of blueberries or strawberries",
                true,
                3.59));

        dinerMenu.add(new MenuItem(
                "Vegetarian BLT",
                "(Fakin') Bacon with lettuce & tomato on whole wheat",
                true,
                2.99));
        dinerMenu.add(new MenuItem(
                "BLT",
                "Bacon with lettuce & tomato on whole wheat",
                false,
                2.99));
        dinerMenu.add(new MenuItem(
                "Soup of the day",
                "A bowl of the soup of the day, with a side of potato salad",
                false,
                3.29));
        dinerMenu.add(new MenuItem(
                "Hotdog",
                "A hot dog, with saurkraut, relish, onions, topped with cheese",
                false,
                3.05));
        dinerMenu.add(new MenuItem(
                "Steamed Veggies and Brown Rice",
                "A medly of steamed vegetables over brown rice",
                true,
                3.99));

        dinerMenu.add(new MenuItem(
                "Pasta",
                "Spaghetti with Marinara Sauce, and a slice of sourdough bread",
                true,
                3.89));

        dinerMenu.add(dessertMenu);

        dessertMenu.add(new MenuItem(
                "Apple Pie",
                "Apple pie with a flakey crust, topped with vanilla icecream",
                true,
                1.59));
        dessertMenu.add(new MenuItem(
                "Cheesecake",
                "Creamy New York cheesecake, with a chocolate graham crust",
                true,
                1.99));
        dessertMenu.add(new MenuItem(
                "Sorbet",
                "A scoop of raspberry and a scoop of lime",
                true,
                1.89));

        cafeMenu.add(new MenuItem(
                "Veggie Burger and Air Fries",
                "Veggie burger on a whole wheat bun, lettuce, tomato, and fries",
                true,
                3.99));
        cafeMenu.add(new MenuItem(
                "Soup of the day",
                "A cup of the soup of the day, with a side salad",
                false,
                3.69));
        cafeMenu.add(new MenuItem(
                "Burrito",
                "A large burrito, with whole pinto beans, salsa, guacamole",
                true,
                4.29));

        Waitress waitress = new Waitress(allMenus);
        waitress.printMenu();

        waitress.printVegetarianMenu();
    }
}

状态模式

定义：状态模式允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类。

状态模式与策略模式的区别

以状态模式而言，其将一群行为封装在状态对象中，context的行为随时可委托到那些状态对象中的一个。随着时间的流逝，当前状态在状态对象集合中游走改变，以反映出context内部的状态，因此context的行为也会跟着改变，但是context的客户对于状态对象了解不多，甚至根本是浑然不觉。

以策略模式而言，客户通常主动指定Context所要组合的策略对象是哪一个。现在，固然策略模式让我们具有弹性，能够在运行时改变策略，但对某各context对象来说，通常都只有一个最适当的策略对象。

GumballMachine实例

package State.gumball;

class GumballMachine {
    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;
        }
    }

    public void insertQuarter() {
        if (state == HAS_QUARTER) {
            System.out.println("You can't insert another quarter");
        } else if (state == NO_QUARTER) {
            state = HAS_QUARTER;
            System.out.println("You inserted a quarter");
        }else if (state == SOLD_OUT){
            System.out.println("You can't insert a quarter, the machine is sold out");
        }else if(state == SOLD){
            System.out.println("Please wait, we're already giving you a gumball");
        }
    }

    public void ejectQuarter(){
        if(state == HAS_QUARTER){
            System.out.println("Quarter returned");
            state = NO_QUARTER;
        }else if(state == NO_QUARTER){
            System.out.println("You haven't inserted a quarter");
        }else if(state == SOLD){
            System.out.println("Sorry, you already turned the crank");
        }else if(state == SOLD_OUT){
            System.out.println("You can't eject, you haven't inserted a quarter yet");
        }
    }

    public void turnCrank(){
        if(state == SOLD){
            System.out.println("Turning twice doesn't get you another gumball!");
        }else if(state == NO_QUARTER){
            System.out.println("You turned but there's no quarter");
        }else if(state == SOLD_OUT){
            System.out.println("You turned, but there are no gumballs");
        }else if(state == HAS_QUARTER){
            System.out.println("You turned...");
            state = SOLD;
            dispense();
        }
    }

    public void dispense(){
        if(state == SOLD){
            System.out.println("A gumball comes rolling out the slot");
            count = count - 1;
            if(count==0){
                System.out.println("Oops, out of gumballs");
                state = SOLD_OUT;
            }else{
                state = NO_QUARTER;
            }
        }else if(state == NO_QUARTER){
            System.out.println("You need to pay first");
        }else if(state == SOLD_OUT){
            System.out.println("No gumball dispensed");
        }else if(state == HAS_QUARTER){
            System.out.println("No gumball dispensed");
        }
    }

    public void refill(int numGumBalls){
        this.count = numGumBalls;
        state = NO_QUARTER;
    }

    public String toString(){
        StringBuffer result = new StringBuffer();
        result.append("\nMighty Gumball, Inc.");
        result.append("\nJava-enabled Standing Gumball Model #2004\n");
        result.append("Inventory: " + count + " gumball");
        if(count != 1){
            result.append("s");
        }
        result.append("\nMachine is ");
        if(state == SOLD_OUT){
            result.append("sold out");
        }else if(state == NO_QUARTER){
            result.append("waiting for quarter");
        }else if(state == HAS_QUARTER){
            result.append("waiting for turn of crank");
        }else if(state == SOLD){
            result.append("delivering a gumball");
        }
        result.append("\n");
        return result.toString();
    }
}

public class GumballMachineTestDrive {
    public static void main(String[] args){
        GumballMachine gumballMachine = new GumballMachine(5);
        System.out.println(gumballMachine);

        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();

        System.out.println(gumballMachine);

        gumballMachine.insertQuarter();
        gumballMachine.ejectQuarter();
        gumballMachine.turnCrank();

        System.out.println(gumballMachine);

        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();
        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();
        gumballMachine.ejectQuarter();

        System.out.println(gumballMachine);

        gumballMachine.insertQuarter();
        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();
        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();
        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();

        System.out.println(gumballMachine);
    }
}

GumballMachineState状态模式实例

设计原则

首先，我们定义了一个State接口。在这个接口内，糖果机的每个动作都有一个对应的方法。
然后为机器中的每个状态实现状态类。这些类将负责在对应的状态下进行机器的行为。

最后，我们要摆脱旧的条件代码，取而代之的方式是，将动作委托到状态类。

package State.gumballState;

import java.awt.*;
import java.util.Random;

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

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

    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);
        winnerState = new WinnerState(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();
    }

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

    public State getState(){
        return state;
    }

    public State getSoldOutState(){
        return soldOutState;
    }

    public State getWinnerState(){
        return winnerState;
    }

    public void releaseBall(){
        System.out.println("A gumball comes rolling out the slot...");
        if(count>0){
            count -= 1;
        }
    }
    public int getCount(){return count;}

    public void refill(int count){
        this.count += count;
        System.out.println("The gumball machine was just refilled; its new count is: " + this.count);
        state.refill();
    }

    public State getNoQuarterState(){
        return noQuarterState;
    }

    public State getHasQuarterState(){
        return hasQuarterState;
    }

    public State getSoldState(){
        return soldState;
    }

    public String toString(){
        StringBuffer result = new StringBuffer();
        result.append("\nMighty Gumball, Inc.");
        result.append("\nJava-enabled Standing Gumball Model #2004");
        result.append("\nInventory: " + count + " gumball");
        if(count != 1){
            result.append("s");
        }
        result.append("\n");
        result.append("Machine is " + state + "\n");
        return result.toString();
    }
}


class HasQuarterState implements State{
    GumballMachine gumballMachine;
    Random randomWinner = new Random(System.currentTimeMillis());
    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());
        int winner = randomWinner.nextInt(10);
        if((winner == 0) && (gumballMachine.getCount() > 1)){
            gumballMachine.setState(gumballMachine.getWinnerState());
        }else{
            gumballMachine.setState(gumballMachine.getSoldState());
        }
    }

    @Override
    public void dispense(){
        System.out.println("No gumball dispensed");
    }

    public void refill(){

    }

    public String toString(){
        return "waiting for turn of crank";
    }
}

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

    @Override
    public void insertQuarter(){
        System.out.println("You inserted a quarter");
        gumballMachine.setState(gumballMachine.getHasQuarterState());
    }

    @Override
    public void ejectQuarter() {
        System.out.println("You haven't inserted a quarter");
    }

    @Override
    public void turnCrank() {
        System.out.println("You turned, but there's no quarter");
    }

    @Override
    public void dispense() {
        System.out.println("You turned, but there's no quarter");
    }

    @Override
    public void refill() {

    }

    public String toString(){
        return "waiting for quarter";
    }
}

class SoldOutState implements State{
    GumballMachine gumballMachine;

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

    public void insertQuarter(){
        System.out.println("You can't insert a quarter, the machine is sold out");
    }

    public void ejectQuarter(){
        System.out.println("You can't eject, you haven't inserted a quarter yet");
    }

    public void turnCrank(){
        System.out.println("You turned, but there are no gumballs");
    }

    public void dispense(){
        System.out.println("No gumball dispensed");
    }

    public void refill(){
        gumballMachine.setState(gumballMachine.getNoQuarterState());
    }

    public String toString(){
        return "sold out";
    }
}

class SoldState implements State{
    GumballMachine gumballMachine;
    public SoldState(GumballMachine gumballMachine){
        this.gumballMachine = gumballMachine;
    }

    public void insertQuarter(){
        System.out.println("Please wait, we're already giving you a gumball");
    }

    public void ejectQuarter(){
        System.out.println("Sorry, you already turned the crank");
    }
    public void turnCrank(){
        System.out.println("Turning twice doesn't get you another gumball!");
    }

    public void dispense(){
        gumballMachine.releaseBall();
        if(gumballMachine.getCount()>0){
            gumballMachine.setState(gumballMachine.getNoQuarterState());
        }else{
            System.out.println("Oops, out of gumballs!You can eject quarter!");
            //gumballMachine.setState(gumballMachine.getSoldOutState()); //吞金兽？
            gumballMachine.setState(gumballMachine.getHasQuarterState());
        }
    }

    @Override
    public void refill() {

    }

    public String toString(){
        return "dispensing a gumball";
    }
}

class WinnerState implements State{
    GumballMachine gumballMachine;

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

    public void insertQuarter(){
        System.out.println("Please wait, we're already giving you a Gumball");
    }

    public void ejectQuarter(){
        System.out.println("Please wait, we're already giving you a Gumball");
    }

    public void turnCrank(){
        System.out.println("Turning again doesn't get you another gumball!");
    }

    public void dispense(){
        gumballMachine.releaseBall();
        if(gumballMachine.getCount() == 0){
            gumballMachine.setState(gumballMachine.getSoldOutState());
        }else{
            gumballMachine.releaseBall();
            System.out.println("YOU'RE A WINNER! You got two gumballs for your quarter");
            if(gumballMachine.getCount() > 0){
                gumballMachine.setState(gumballMachine.getNoQuarterState());
            }else{
                System.out.println("Oops, out of gumballs!");
                gumballMachine.setState(gumballMachine.getSoldOutState());
            }
        }
    }

    public void refill(){}

    public String toString(){
        return "despensing two gumballs for your quarter, because YOU'RE A WINNER!";
    }
}
public class GumballTestDrive {
    public static void main(String[] args){
        GumballMachine gumballMachine = new GumballMachine(10);

        System.out.println(gumballMachine);

        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();

        System.out.println(gumballMachine);

        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();
        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();

        System.out.println(gumballMachine);

        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();
        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();

        System.out.println(gumballMachine);

        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();
        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();

        System.out.println(gumballMachine);

        gumballMachine.refill(5);
        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();

        System.out.println(gumballMachine);
    }
}

代理模式

定义：代理模式为另一个对象提供一个替身或占位符以控制对这个对象的访问。

代理与装饰者模式的区别：
（1）装饰者为对象增加行为，而代理是控制对象的访问。
（2）代理将客户从具体对象中解耦，比如ImageProxy中，如果客户没有从ImageIcon中解耦，那么客户就必须等到每幅图像都被取回，然后才能把它绘制在界面上。
（3）代理代表对象，不光是为对象加上动作。客户使用我作为主题的替身，因为我可以保护对象避免不想要的访问，也可以避免在加载大对象的过程中GUI会挂起，或者隐藏主题在远程运行的事实。
（4）虚拟代理中，当客户第一次用代理的时候，主题甚至还根本不存在，所以此时并没有装饰者模式的包装对象的概念。

代理分类

（1）防火墙代理(Firewall Proxy)：控制网络资源的访问，保护主题免于“坏客户”的侵害；
（2）智能引用代理(Smart Reference Proxy)：当主题被引用时，进行额外的动作，例如计算一个对象被引用的次数；
（3）缓存代理(Caching Proxy)：为开销大的运算结果提供暂时存储：它也允许多个客户共享结果，以减少计算或网络延迟；
（4）同步代理(Synchronization Proxy)：在多线程的情况下为主题提供安全的访问；
（5）复杂隐藏代理(Complexity Hiding Proxy)：用来隐藏一个类的复杂集合的复杂度，并进行访问控制。有时候也称为外观代理(Facade Proxy)，这不难理解。复杂隐藏代理和外观模式是不一样的，因为代理控制访问，而外观模式只提供另一组接口；
（6）写入时复制代理(Copy-On-Write-Proxy)：用来控制对象的复制，方法是延迟对象的复制，直到客户真的需要为止。这是虚拟代理的变体。

远程代理

GumballMachineRemote

package ProxyPattern.Gumball;

import java.rmi.Remote;
import java.rmi.RemoteException;

public interface GumballMachineRemote extends Remote {
    int getCount() throws RemoteException;
    String getLocation() throws RemoteException;
    State getState() throws RemoteException;
}

GumballMachine

package ProxyPattern.Gumball;

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

//继承UnicastRemoteObject，以成为一个远程服务
//GumballMachineRemote实现远程接口
public class GumballMachine extends UnicastRemoteObject implements GumballMachineRemote {
    private static final long serialVersionUID = 2L;

    State soldOutState;
    State noQuarterState;
    State hasQuarterState;
    State soldState;
    State winnerState;

    int count = 0;
    String location;
    State state = soldOutState;

    public GumballMachine(String location, int numberGumballs) throws RemoteException {
        soldOutState = new SoldOutState(this);
        noQuarterState = new NoQuarterState(this);
        hasQuarterState = new HasQuarterState(this);
        soldState = new SoldOutState(this);
        winnerState = new WinnerState(this);

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

    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("A gumball comes rolling out the slot...");
        if (count != 0) {
            count = count - 1;
        }
    }

    public void refill(int count) {
        this.count = count;
        state = noQuarterState;
    }

    public int getCount() {
        return count;
    }

    public State getState() {
        return state;
    }

    public String getLocation() {
        return location;
    }

    public State getSoldOutState() {
        return soldOutState;
    }

    public State getNoQuarterState() {
        return noQuarterState;
    }

    public State getHasQuarterState() {
        return hasQuarterState;
    }

    public State getSoldState() {
        return soldState;
    }

    public State getWinnerState() {
        return winnerState;
    }

    public String toString() {
        StringBuffer result = new StringBuffer();
        result.append("\nMighty Gumball, Inc.");
        result.append("\nJava-enabled Standing Gumball Model #2014");
        result.append("\nInventory: " + count + " gumball");
        if (count != 1) {
            result.append("s");
        }
        result.append("\n");
        result.append("Machine is " + state + "\n");
        return result.toString();
    }
}

GumballMonitor

package ProxyPattern.Gumball;

import java.rmi.RemoteException;

public class GumballMonitor {
    GumballMachineRemote machine;

    public GumballMonitor(GumballMachineRemote machine){
        this.machine = machine;
    }

    public void report(){
        try{
            System.out.println("Gumball Machine: " + machine.getLocation());
            System.out.println("Current inventory: " + machine.getCount() + " gumballs");
            System.out.println("Current state: " + machine.getState());
        }catch (RemoteException e){
            e.printStackTrace();
        }
    }
}

State

package ProxyPattern.Gumball;

import java.io.Serializable;

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

HasQuarterState

package ProxyPattern.Gumball;

import java.util.Random;

public class HasQuarterState implements State{
    private static final long serialVersionUID = 2L;
    Random randomWinner = new Random(System.currentTimeMillis());
    transient GumballMachine gumballMachine;

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

    public void insertQuarter(){
        System.out.println("You can't insert another quarter");
    }

    public void ejectQuarter(){
        System.out.println("Quarter returned");
        gumballMachine.setState(gumballMachine.getNoQuarterState());
    }

    public void turnCrank(){
        System.out.println("You turned...");
        int winner = randomWinner.nextInt(10);
        if(winner == 0){
            gumballMachine.setState(gumballMachine.getWinnerState());
        }else gumballMachine.setState(gumballMachine.getSoldState());
    }

    public void dispense(){
        System.out.println("No gumball dispensed");
    }

    public String toString(){
        return "waiting for turn of crank";
    }
}

NoQuarterState

package ProxyPattern.Gumball;

public class NoQuarterState implements State{
    private static final long serialVersionUID = 2L;
    transient GumballMachine gumballMachine;

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

    public void insertQuarter(){
        System.out.println("You inserted a quarter");
        gumballMachine.setState(gumballMachine.getHasQuarterState());
    }

    public void ejectQuarter(){
        System.out.println("You haven't inserted a quarter");
    }

    public void turnCrank(){
        System.out.println("You turned, but there's no quarter");
    }

    public void dispense(){
        System.out.println("You need to pay first");
    }

    public String toString(){
        return "waiting for quarter";
    }
}

SoldOutState

package ProxyPattern.Gumball;

public class SoldOutState implements State {
    private static final long serialVersionUID = 2L;
    transient GumballMachine gumballMachine;

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

    public void insertQuarter(){
        System.out.println("You can't insert a quarter, the machine is sold out");
    }

    public void ejectQuarter(){
        System.out.println("You can't eject, you haven't inserted a quarter yet");
    }

    public void turnCrank(){
        System.out.println("You turned, but there are no gumballs");
    }

    public void dispense(){
        System.out.println("No gumball dispensed");
    }

    public String toString(){
        return "sold out";
    }
}

SoldState

package ProxyPattern.Gumball;

public class SoldState implements State {
    private static final long serialVersionUID = 2L;
    transient GumballMachine gumballMachine;

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

    public void insertQuarter(){
        System.out.println("Please wait, we're already giving you a gumball");
    }

    public void ejectQuarter(){
        System.out.println("Sorry, you already turned the crank");
    }

    public void turnCrank(){
        System.out.println("Turning twice doesn't get you another gumball!");
    }

    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());
        }
    }

    public String toString(){
        return "dispensing a gumball";
    }
}

WinnerState

package ProxyPattern.Gumball;

public class WinnerState implements State {
    private static final long serialVersionUID = 2L;
    transient GumballMachine gumballMachine;

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

    public void insertQuarter(){
        System.out.println("Please wait, we're already giving you a Gumball");
    }

    public void ejectQuarter(){
        System.out.println("Please wait, we're already giving you a Gumball");
    }

    public void turnCrank(){
        System.out.println("Turning again doesn't get yout another gumball!");
    }

    public void dispense(){
        System.out.println("YOU'RE A WINNER! You get two gumballs for your quarter");
        gumballMachine.releaseBall();
        if(gumballMachine.getCount() == 0){
            gumballMachine.setState(gumballMachine.getSoldOutState());
        }else{
            gumballMachine.releaseBall();
            if(gumballMachine.getCount() > 0){
                gumballMachine.setState(gumballMachine.getNoQuarterState());
            }else{
                System.out.println("Oops, out of gumballs!");
                gumballMachine.setState(gumballMachine.getSoldOutState());
            }
        }
    }

    public String toString(){
        return "despensing two gumballs for your quarter, because YOU'RE A WINNER!";
    }
}

GumballMonitorTestDrive

package ProxyPattern.Gumball;

import java.rmi.Naming;

public class GumballMonitorTestDrive {

    public static void main(String[] args) {
        String[] location = {"rmi://santafe.mightygumball.com/gumballmachine",
                "rmi://boulder.mightygumball.com/gumballmachine",
                "rmi://austin.mightygumball.com/gumballmachine"};

//        if (args.length == 1) {
//            location = new String[1];
//            location[0] = "rmi://" + args[0] + "/gumballmachine";
//        }

        GumballMonitor[] monitors = new GumballMonitor[location.length];

        for(int i=0;i<location.length;i++){
            try{
                GumballMachineRemote machine = (GumballMachineRemote) Naming.lookup(location[i]);
                monitors[i] = new GumballMonitor(machine);
                System.out.println(monitors[i]);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        for(int i=0;i<monitors.length;i++){
            monitors[i].report();
        }
    }
}

虚拟代理

ImageComponent

package ProxyPattern.VirtualProxy;

import javax.swing.*;
import java.awt.*;

public class ImageComponent extends JComponent {
    private static final long serialVersionUID = 1L;
    private Icon icon;

    public ImageComponent(Icon icon){
        this.icon = icon;
    }

    public void setIcon(Icon icon){
        this.icon = icon;
    }

    public void paintComponent(Graphics g){
        super.paintComponent(g);
        int w = icon.getIconWidth();
        int h = icon.getIconHeight();
        int x = (800 - w)/2;
        int y = (600 - h)/2;
        icon.paintIcon(this, g, x, y);
    }
}

ImageProxy

package ProxyPattern.VirtualProxy;

import javax.swing.*;
import java.awt.*;
import java.net.URL;

public class ImageProxy implements Icon {
    volatile ImageIcon imageIcon;
    final URL imageURL;
    Thread retrievalThread;
    boolean retrieving = false;

    public ImageProxy(URL url) {
        imageURL = url;
    }

    public int getIconWidth() {
        if (imageIcon != null) {
            return imageIcon.getIconWidth();
        } else {
            return 800;
        }
    }

    public int getIconHeight() {
        if (imageIcon != null) {
            return imageIcon.getIconHeight();
        } else {
            return 600;
        }
    }

    synchronized void setImageIcon(ImageIcon imageIcon) {
        this.imageIcon = imageIcon;
    }

    public void paintIcon(final Component c, Graphics g, int x, int y) {
        if (imageIcon != null) {
            imageIcon.paintIcon(c, g, x, y);
        } else {
            g.drawString("Loading album cover, please wait...", x + 300, y + 190);
            if (!retrieving) {
                retrieving = true;
                retrievalThread = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            setImageIcon(new ImageIcon(imageURL, "Album Cover"));
                            c.repaint();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                });

                retrievalThread.start();
            }
        }
    }
}

ImageProxyTestDrive

package ProxyPattern.VirtualProxy;

import javax.swing.*;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Enumeration;
import java.util.Hashtable;

public class ImageProxyTestDrive {
    ImageComponent imageComponent;
    JFrame frame = new JFrame("Album Cover Viewer");
    JMenuBar menuBar;
    JMenu menu;

    Hashtable<String, String> albums = new Hashtable<>();

    public static void main(String[] args) throws Exception{
        ImageProxyTestDrive testDrive = new ImageProxyTestDrive();
    }

    public ImageProxyTestDrive() throws Exception{
        albums.put("Buddha Bar","http://images.amazon.com/images/P/B00009XBYK.01.LZZZZZZZ.jpg");
        albums.put("Ima","http://images.amazon.com/images/P/B000005IRM.01.LZZZZZZZ.jpg");
        albums.put("Karma","http://images.amazon.com/images/P/B000005DCB.01.LZZZZZZZ.gif");
        albums.put("MCMXC a.D.","http://images.amazon.com/images/P/B000002URV.01.LZZZZZZZ.jpg");
        albums.put("Northern Exposure","http://images.amazon.com/images/P/B000003SFN.01.LZZZZZZZ.jpg");
        albums.put("Selected Ambient Works, Vol. 2","http://images.amazon.com/images/P/B000002MNZ.01.LZZZZZZZ.jpg");

        URL initialURL = new URL((String)albums.get("Selected Ambient Works, Vol. 2"));
        menuBar = new JMenuBar();
        menu = new JMenu("Favorite Albums");
        menuBar.add(menu);
        frame.setJMenuBar(menuBar);

        for(Enumeration<String> e = albums.keys();e.hasMoreElements();){
            String name = (String) e.nextElement();
            JMenuItem menuItem = new JMenuItem(name);
            menu.add(menuItem);
            menuItem.addActionListener(event -> {
                imageComponent.setIcon(new ImageProxy(getAlbumUrl(event.getActionCommand())));
                frame.repaint();
            });
        }

        Icon icon = new ImageProxy(initialURL);
        imageComponent = new ImageComponent(icon);
        frame.getContentPane().add(imageComponent);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(800, 600);
        frame.setVisible(true);
    }

    URL getAlbumUrl(String name){
        try{
            return new URL((String) albums.get(name));
        }catch (MalformedURLException e){
            e.printStackTrace();
            return null;
        }
    }
}

Java代理

Person

package ProxyPattern.JavaProxy;

public interface Person {
    String getName();
    String getGender();
    String getInterests();
    int getGeekRating();

    void setName(String name);
    void setGender(String gender);
    void setInterests(String interests);
    void setGeekRating(int rating);
}

PersonImpl

package ProxyPattern.JavaProxy;

public class PersonImpl implements Person{
    String name;
    String gender;
    String interests;
    int rating;
    int ratingCount = 0;

    public String getName(){
        return name;
    }

    public String getGender(){ return gender;}

    public String getInterests(){
        return interests;
    }

    public int getGeekRating(){
        if(ratingCount == 0) return 0;
        return rating / ratingCount;
    }

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

    public void setGender(String gender){
        this.gender = gender;
    }

    public void setInterests(String interests){
        this.interests = interests;
    }

    public void setGeekRating(int rating){
        this.rating += rating;
        ratingCount++;
    }
}

OwnerInvocationHandler

package ProxyPattern.JavaProxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class OwnerInvocationHandler implements InvocationHandler {
    Person person;

    public OwnerInvocationHandler(Person person){
        this.person = person;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws IllegalAccessException{
        try{
            if(method.getName().startsWith("get")){
                return method.invoke(person, args);
            }else if(method.getName().equals("setGeekRating")){
                throw new IllegalAccessException();
            }else if(method.getName().startsWith("set")){
                return method.invoke(person, args);
            }
        }catch(InvocationTargetException e){
            e.printStackTrace();
        }
        return null;
    }

}

NonOwnerInvocationHandler

package ProxyPattern.JavaProxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class NonOwnerInvocationHandler implements InvocationHandler {
    Person person;

    public NonOwnerInvocationHandler(Person person){
        this.person = person;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws IllegalAccessException{
        try{
            if(method.getName().startsWith("get")){
                return method.invoke(person, args);
            }else if(method.getName().equals("setGeekRating")){
                return method.invoke(person, args);
            }else if(method.getName().startsWith("set")){
                throw new IllegalAccessException();
            }
        }catch (InvocationTargetException e){
            e.printStackTrace();
        }
        return null;
    }
}

MatchMakingTestDrive

package ProxyPattern.JavaProxy;

import java.lang.reflect.Proxy;
import java.util.HashMap;

public class MatchMakingTestDrive {
    HashMap<String, Person> datingDB = new HashMap<>();
    public static void main(String[] args){
        MatchMakingTestDrive test = new MatchMakingTestDrive();
        test.drive();
    }

    public MatchMakingTestDrive(){
        initializeDatabase();
    }

    public void drive(){
        Person joe = getPersonFromDatabase("Joe Javabean");
        Person ownerProxy = getOwnerProxy(joe);
        System.out.println("Name is " + ownerProxy.getName());
        ownerProxy.setInterests("bowling, Go");
        System.out.println("Interests set from owner proxy");
        try{
            ownerProxy.setGeekRating(10);
        }catch (Exception e){
            System.out.println("Can't set rating from owner proxy");
        }

        System.out.println("Rating is " + ownerProxy.getGeekRating());

        Person nonOwnerProxy = getNonOwnerProxy(joe);
        System.out.println("Name is " + nonOwnerProxy.getName());
        try{
            nonOwnerProxy.setInterests("bowling, Go");
        }catch (Exception e){
            System.out.println("Can't set interests from non owner proxy");
        }

        nonOwnerProxy.setGeekRating(3);
        System.out.println("Rating set from non owner proxy");
        System.out.println("Rating is " + nonOwnerProxy.getGeekRating());
    }

    Person getNonOwnerProxy(Person person){
        return (Person) Proxy.newProxyInstance(
          person.getClass().getClassLoader(),
          person.getClass().getInterfaces(),
          new NonOwnerInvocationHandler(person)
        );
    }
    Person getOwnerProxy(Person person){
        return (Person) Proxy.newProxyInstance(
                person.getClass().getClassLoader(),
                person.getClass().getInterfaces(),
                new OwnerInvocationHandler(person)
        );
    }
    Person getPersonFromDatabase(String name){
        return (Person)datingDB.get(name);
    }

    void initializeDatabase(){
        Person joe = new PersonImpl();
        joe.setName("Joe Javabean");
        joe.setInterests("cars, computers, music");
        joe.setGeekRating(7);
        datingDB.put(joe.getName(), joe);

        Person kelly = new PersonImpl();
        kelly.setName("Keylly Klosure");
        kelly.setInterests("ebay, movies, music");
        kelly.setGeekRating(6);
        datingDB.put(kelly.getName(), kelly);
    }
}

复合模式

定义：模式通常被一起使用，并被组合在同一个设计解决方案中。复合模式在一个解决方案中结合两个或多个模式，以解决一般或重复发生的问题。

模型携手工作

package CombinedPattern;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/*
观察者、主题
 */
interface Observer{
    void update(QuackObservable duck);
}

interface QuackObservable{
    void registerObserver(Observer observer);
    void notifyObservers();
}

interface Quackable extends QuackObservable{
    void quack();
}

/*
抽象工厂模式
 */
abstract class AbstractDuckFactory{
    public abstract Quackable createMallardDuck();
    public abstract Quackable createRedheadDuck();
    public abstract Quackable createDuckCall();
    public abstract Quackable createRubberDuck();
}

/*
Subject
被用于后续Duck的策略模式，有的需要策略，有的不需要策略，Duck可以灵活选择，
同时也不需要每个需要策略的Duck类重复代码
 */
class Observable implements QuackObservable{
    List<Observer> observers = new ArrayList<>();
    QuackObservable duck;

    public Observable(QuackObservable duck){
        this.duck = duck;
    }

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

    public void notifyObservers(){
        Iterator<Observer> iterator = observers.iterator();
        while(iterator.hasNext()){
            Observer observer = iterator.next();
            observer.update(duck);
        }
    }

    public Iterator<Observer> getObservers(){
        return observers.iterator();
    }
}

class MallardDuck implements Quackable{
    Observable observable;
    public MallardDuck(){
        observable = new Observable(this);
    }

    public void quack(){
        System.out.println("Quack");
        notifyObservers();
    }

    public void registerObserver(Observer observer){
        observable.registerObserver(observer);
    }

    public void notifyObservers(){
        observable.notifyObservers();
    }

    public String toString(){
        return "Mallard Duck";
    }
}

class RedheadDuck implements Quackable{
    Observable observable;

    public RedheadDuck(){
        observable = new Observable(this);
    }

    public void quack(){
        System.out.println("Quack");
        notifyObservers();
    }

    public void registerObserver(Observer observer){
        observable.registerObserver(observer);
    }

    public void notifyObservers(){
        observable.notifyObservers();
    }

    public String toString(){
        return "Redhead Duck";
    }
}

class DuckCall implements Quackable{
    Observable observable;

    public DuckCall(){
        observable = new Observable(this);
    }

    @Override
    public void quack() {
        System.out.println("Kwak");
        notifyObservers();
    }

    @Override
    public void registerObserver(Observer observer) {
        observable.registerObserver(observer);
    }

    @Override
    public void notifyObservers() {
        observable.notifyObservers();
    }

    public String toString(){
        return "Duck Call";
    }
}

class RubberDuck implements Quackable{
    Observable observable;

    public RubberDuck(){
        observable = new Observable(this);
    }

    @Override
    public void quack() {
        System.out.println("Squeak");
        notifyObservers();
    }

    @Override
    public void registerObserver(Observer observer) {
        observable.registerObserver(observer);
    }

    @Override
    public void notifyObservers() {
        observable.notifyObservers();
    }

    public String toString(){
        return "Rubber Duck";
    }
}

class DecoyDuck implements Quackable{
    Observable observable;

    public DecoyDuck(){
        observable = new Observable(this);
    }

    @Override
    public void quack() {
        System.out.println("<< Silence >>");
        notifyObservers();
    }

    @Override
    public void registerObserver(Observer observer) {
        observable.registerObserver(observer);
    }

    @Override
    public void notifyObservers() {
        observable.notifyObservers();
    }

    public String toString(){
        return "Decoy Duck";
    }
}

/*
观察者
 */
class Quackologist implements Observer{
    @Override
    public void update(QuackObservable duck) {
        System.out.println("Quackologist: " + duck + " just quacked.");
    }

    public String toString(){
        return "Quackologist";
    }
}
/*
适配器
 */
class Goose{
    public void honk(){
        System.out.println("Honk");
    }

    public String toString(){
        return "Goose";
    }
}

class GooseAdapter implements Quackable{
    Goose goose;
    Observable observable;
    public GooseAdapter(Goose goose){
        this.goose = goose;
        observable = new Observable(this);
    }

    public void quack(){
        goose.honk();
        notifyObservers();
    }

    @Override
    public void registerObserver(Observer observer) {
        observable.registerObserver(observer);
    }

    @Override
    public void notifyObservers() {
        observable.notifyObservers();
    }

    public String toString(){
        return "Goose pretending to be a Duck";
    }
}

/*
记录并通知创建了多少同种Duck
 */
class QuackCounter implements Quackable{
    Quackable duck; //策略模式应用，这里可以通过适配器包装非Duck类，然后复用该Counter类
    static int numberOfQuacks;

    public QuackCounter(Quackable duck){
        this.duck = duck;
    }

    @Override
    public void quack() {
        duck.quack();
        numberOfQuacks++;
    }

    public static int getQuacks(){
        return numberOfQuacks;
    }

    @Override
    public void registerObserver(Observer observer) {
        duck.registerObserver(observer);
    }

    @Override
    public void notifyObservers() {
        duck.notifyObservers();
    }

    public String toString(){
        return duck.toString();
    }
}

//抽象工厂类
class DuckFactory extends AbstractDuckFactory{

    @Override
    public Quackable createMallardDuck() {
        return new MallardDuck();
    }

    @Override
    public Quackable createRedheadDuck() {
        return new RedheadDuck();
    }

    @Override
    public Quackable createDuckCall() {
        return new DuckCall();
    }

    @Override
    public Quackable createRubberDuck() {
        return new RubberDuck();
    }
}

class CountingDuckFactory extends AbstractDuckFactory{
    @Override
    public Quackable createMallardDuck() {
        return new QuackCounter(new MallardDuck());
    }

    @Override
    public Quackable createRedheadDuck() {
        return new QuackCounter(new RedheadDuck());
    }

    @Override
    public Quackable createDuckCall() {
        return new QuackCounter(new DuckCall());
    }

    @Override
    public Quackable createRubberDuck() {
        return new QuackCounter(new RubberDuck());
    }
}

/*
管理鸭子群
 */
class Flock implements Quackable{
    List<Quackable> ducks = new ArrayList<>();

    public void add(Quackable duck){
        ducks.add(duck);
    }

    @Override
    public void quack() {
        Iterator<Quackable> iterator = ducks.iterator();
        while(iterator.hasNext()){
            Quackable duck = (Quackable)iterator.next();
            duck.quack();
        }
    }

    @Override
    public void registerObserver(Observer observer) {
        Iterator<Quackable> iterator = ducks.iterator();
        while(iterator.hasNext()){
            Quackable duck = (Quackable) iterator.next();
            duck.registerObserver(observer);
        }
    }

    @Override
    public void notifyObservers() {

    }

    public String toString(){
        return "Flock of Ducks";
    }
}

public class DuckSimulator {
    public static void main(String[] args){
        DuckSimulator simulator = new DuckSimulator();
        AbstractDuckFactory duckFactory = new CountingDuckFactory();

        simulator.simulate(duckFactory);
    }

    void simulate(AbstractDuckFactory duckFactory){
        Quackable redheadDuck = duckFactory.createRedheadDuck();
        Quackable duckCall = duckFactory.createDuckCall();
        Quackable rubberDuck = duckFactory.createRubberDuck();
        Quackable gooseDuck = new GooseAdapter(new Goose());

        Flock flockOfDucks = new Flock();

        flockOfDucks.add(redheadDuck);
        flockOfDucks.add(duckCall);
        flockOfDucks.add(rubberDuck);
        flockOfDucks.add(gooseDuck);

        Flock flockOfMallards = new Flock();

        Quackable mallardOne = duckFactory.createMallardDuck();
        Quackable mallardTwo = duckFactory.createMallardDuck();
        Quackable mallardThree = duckFactory.createMallardDuck();
        Quackable mallardFour = duckFactory.createMallardDuck();

        flockOfMallards.add(mallardOne);
        flockOfMallards.add(mallardTwo);
        flockOfMallards.add(mallardThree);
        flockOfMallards.add(mallardFour);

        flockOfDucks.add(flockOfMallards);

        System.out.println("\nDuck Simulator: With Observer");

        Quackologist quackologist = new Quackologist();
        flockOfDucks.registerObserver(quackologist);

        simulate(flockOfDucks);

        System.out.println("\nThe ducks quacked " + QuackCounter.getQuacks() + " times");
    }

    void simulate(Quackable duck){
        duck.quack();
    }
}

Duck Simulator: With Observer
Quack
Quackologist: Redhead Duck just quacked.
Kwak
Quackologist: Duck Call just quacked.
Squeak
Quackologist: Rubber Duck just quacked.
Honk
Quackologist: Goose pretending to be a Duck just quacked.
Quack
Quackologist: Mallard Duck just quacked.
Quack
Quackologist: Mallard Duck just quacked.
Quack
Quackologist: Mallard Duck just quacked.
Quack
Quackologist: Mallard Duck just quacked.

The ducks quacked 7 times

Process finished with exit code 0

MVC(模型-视图-控制器)

Model（模型）—— 代表一个存取数据的对象或JAVA POJO。它也可以带有逻辑，在数据变化时更新控制器；
View（视图）—— 代表模型包含的数据的可视化；
Controller（控制器）—— 作用于模型和视图上。它控制数据流向模型对象，并在数据变化时更新视图。它使视图与模型分离开。

package CombinedPattern;

import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.Clip;
import javax.sound.sampled.Line;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File;
import java.security.PublicKey;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

interface BeatModelInterface {
    void initialize();

    void on();

    void off();

    void setBPM(int bpm);

    int getBPM();

    void registerObserver(BeatObserver o);

    void removeObserver(BeatObserver o);

    void registerObserver(BPMObserver o);

    void removeObserver(BPMObserver o);
}

interface HeartModelInterface{
    int getHeartRate();
    void registerObserver(BeatObserver o);
    void removeObserver(BeatObserver o);
    void registerObserver(BPMObserver o);
    void removeObserver(BPMObserver o);
}

interface BeatObserver {
    void updateBeat();
}

interface BPMObserver {
    void updateBPM();
}

interface ControllerInterface {
    void start();
    void stop();
    void increaseBPM();
    void decreaseBPM();
    void setBPM(int bpm);
}

class BeatBar extends JProgressBar implements Runnable{
    private static final long serialVersionoUID = 2L;
    JProgressBar progressBar;
    Thread thread;

    public BeatBar(){
        thread = new Thread(this);
        setMaximum(100);
        thread.start();
    }

    public void run(){
        for(;;){
            int value = getValue();
            value = (int) (value * .75);
            setValue(value);
            repaint();
            try{
                Thread.sleep(50);
            }catch (Exception e){}
        }
    }
}

class BeatModel implements BeatModelInterface, Runnable {
    List<BeatObserver> beatObservers = new ArrayList<BeatObserver>();
    List<BPMObserver> bpmObservers = new ArrayList<BPMObserver>();
    int bpm = 90;
    Thread thread;
    boolean stop = false;
    Clip clip;

    public void initialize() {
        try {
            File resource = new File("src/resources/clap.wav");
            clip = (Clip) AudioSystem.getLine(new Line.Info(Clip.class));
            clip.open(AudioSystem.getAudioInputStream(resource));
        } catch (Exception e) {
            System.out.println("Error: Can't load clip");
            System.out.println(e);
        }
    }

    public void on() {
        bpm = 90;
        //notifyBPMObservers();
        thread = new Thread(this);
        stop = false;
        thread.start();
    }

    public void off() {
        stopBeat();
        stop = true;
    }

    public void run() {
        while (!stop) {
            playBeat();
            notifyBeatObservers();
            try {
                Thread.sleep(60000 / getBPM());
            } catch (Exception e) {
            }
        }
    }

    public void setBPM(int bpm) {
        this.bpm = bpm;
        notifyBPMObservers();
    }

    public int getBPM() {
        return bpm;
    }

    public void registerObserver(BeatObserver o) {
        beatObservers.add(o);
    }

    public void notifyBeatObservers() {
        for (int i = 0; i < beatObservers.size(); i++) {
            BeatObserver observer = (BeatObserver) beatObservers.get(i);
            observer.updateBeat();
        }
    }

    public void registerObserver(BPMObserver o) {
        bpmObservers.add(o);
    }

    public void notifyBPMObservers() {
        for (int i = 0; i < bpmObservers.size(); i++) {
            BPMObserver observer = (BPMObserver) bpmObservers.get(i);
            observer.updateBPM();
        }
    }
    @Override
    public void removeObserver(BeatObserver o) {
        int i = beatObservers.indexOf(o);
        if (i >= 0) beatObservers.remove(i);
    }
    @Override
    public void removeObserver(BPMObserver o) {
        int i = bpmObservers.indexOf(o);
        if (i >= 0) bpmObservers.remove(i);
    }

    public void playBeat() {
        clip.setFramePosition(0);
        clip.start();
    }

    public void stopBeat() {
        clip.setFramePosition(0);
        clip.stop();
    }
}

class HeartModel implements HeartModelInterface, Runnable{
    ArrayList<BeatObserver> beatObservers = new ArrayList<>();
    ArrayList<BPMObserver> bpmObservers = new ArrayList<>();
    int time = 1000;
    int bpm = 90;
    Random random = new Random(System.currentTimeMillis());
    Thread thread;

    public HeartModel(){
        thread = new Thread(this);
        thread.start();
    }

    public void run(){
        int lastrate = -1;

        for(;;){
            int change = random.nextInt(10);
            if(random.nextInt(2) == 0){
                change = 0 - change;
            }

            int rate = 60000/(time + change);
            if(rate < 120 && rate > 50){
                time += change;
                notifyBeatObservers();
                if(rate != lastrate){
                    lastrate = rate;
                    notifyBPMObservers();
                }
            }

            try{
                Thread.sleep(time);
            }catch (Exception e) {}
        }
    }

    public int getHeartRate(){
        return 60000/time;
    }

    public void registerObserver(BeatObserver o){
        beatObservers.add(o);
    }
    @Override
    public void removeObserver(BeatObserver o){
        int i = beatObservers.indexOf(o);
        if(i >= 0) beatObservers.remove(i);
    }

    public void notifyBeatObservers(){
        for(int i=0;i<beatObservers.size();i++){
            BeatObserver observer = (BeatObserver) beatObservers.get(i);
            observer.updateBeat();
        }
    }

    public void registerObserver(BPMObserver o){
        bpmObservers.add(o);
    }
    @Override
    public void removeObserver(BPMObserver o){
        int i = bpmObservers.indexOf(o);
        if(i >= 0) bpmObservers.remove(i);
    }

    public void notifyBPMObservers(){
        for(int i=0;i<bpmObservers.size();i++){
            BPMObserver observer = (BPMObserver) bpmObservers.get(i);
            observer.updateBPM();
        }
    }

}

class HeartAdapter implements BeatModelInterface{
    HeartModelInterface heart;
    public HeartAdapter(HeartModelInterface heart){
        this.heart = heart;
    }

    public void initialize(){}

    public void on(){}

    public void off(){}

    public int getBPM(){
        return heart.getHeartRate();
    }

    public void setBPM(int bpm){}

    public void registerObserver(BeatObserver o){
        heart.registerObserver(o);
    }

    public void removeObserver(BeatObserver o){
        heart.removeObserver(o);
    }

    public void registerObserver(BPMObserver o){
        heart.registerObserver(o);
    }

    public void removeObserver(BPMObserver o){
        heart.removeObserver(o);
    }
}

class DJView implements ActionListener, BeatObserver, BPMObserver {
    BeatModelInterface model;
    ControllerInterface controller;
    JFrame viewFrame;
    JPanel viewPanel;
    BeatBar beatBar;
    JLabel bpmOutputLabel;
    JFrame controlFrame;
    JPanel controlPanel;
    JLabel bpmLabel;
    JTextField bpmTextField;
    JButton setBPMButton;
    JButton increaseBPMButton;
    JButton decreaseBPMButton;
    JMenuBar menuBar;
    JMenu menu;
    JMenuItem startMenuItem;
    JMenuItem stopMenuItem;

    public DJView(ControllerInterface controller, BeatModelInterface model) {
        this.controller = controller;
        this.model = model;
        model.registerObserver((BeatObserver) this);
        model.registerObserver((BPMObserver) this);
    }

    public void createView() {
        //Create all Swing components here
        viewPanel = new JPanel(new GridLayout(1, 2));
        viewFrame = new JFrame("View");
        viewFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        viewFrame.setSize(new Dimension(100, 80));
        bpmOutputLabel = new JLabel("offline", SwingConstants.CENTER);
        beatBar = new BeatBar();
        beatBar.setValue(0);
        JPanel bpmPanel = new JPanel(new GridLayout(2, 1));
        bpmPanel.add(beatBar);
        viewPanel.add(bpmPanel);
        viewFrame.getContentPane().add(viewPanel, BorderLayout.CENTER);
        viewFrame.pack();
        viewFrame.setVisible(true);
    }

    public void createControls() {
        //Create all Swing components here
        JFrame.setDefaultLookAndFeelDecorated(true);
        controlFrame = new JFrame("Control");
        controlFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        controlFrame.setSize(new Dimension(100, 80));

        controlPanel = new JPanel(new GridLayout(1, 2));

        menuBar = new JMenuBar();
        menu = new JMenu("DJ Control");
        startMenuItem = new JMenuItem("Start");
        menu.add(startMenuItem);
        startMenuItem.addActionListener((event) -> controller.start());

        stopMenuItem = new JMenuItem("Stop");
        menu.add(stopMenuItem);
        stopMenuItem.addActionListener((event) -> controller.stop());

        JMenuItem exit = new JMenuItem("Quit");
        exit.addActionListener((event) -> System.exit(0));

        menu.add(exit);
        menuBar.add(menu);
        controlFrame.setJMenuBar(menuBar);

        bpmTextField = new JTextField(2);
        bpmLabel = new JLabel("Enter BPM:", SwingConstants.RIGHT);
        setBPMButton = new JButton("Set");
        setBPMButton.setSize(new Dimension(10, 40));
        increaseBPMButton = new JButton(">>");
        decreaseBPMButton = new JButton("<<");
        setBPMButton.addActionListener(this);
        increaseBPMButton.addActionListener(this);
        decreaseBPMButton.addActionListener(this);

        JPanel buttonPanel = new JPanel(new GridLayout(1, 2));
        buttonPanel.add(decreaseBPMButton);
        buttonPanel.add(increaseBPMButton);

        JPanel enterPanel = new JPanel(new GridLayout(1, 2));
        enterPanel.add(bpmLabel);
        enterPanel.add(bpmTextField);
        JPanel insideControlPanel = new JPanel(new GridLayout(3, 1));
        insideControlPanel.add(enterPanel);
        insideControlPanel.add(setBPMButton);
        insideControlPanel.add(buttonPanel);
        controlPanel.add(insideControlPanel);

        bpmLabel.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
        bpmOutputLabel.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));

        controlFrame.getRootPane().setDefaultButton(setBPMButton);
        controlFrame.getContentPane().add(controlPanel, BorderLayout.CENTER);

        controlFrame.pack();
        controlFrame.setVisible(true);
    }

    public void enableStopMenuItem() {
        stopMenuItem.setEnabled(true);
    }

    public void disableStopMenuItem() {
        stopMenuItem.setEnabled(false);
    }

    public void enableStartMenuItem() {
        startMenuItem.setEnabled(true);
    }

    public void disableStartMenuItem() {
        startMenuItem.setEnabled(false);
    }

    public void actionPerformed(ActionEvent event) {
        if (event.getSource() == setBPMButton) {
            int bpm = 90;
            String bpmText = bpmTextField.getText();
            if (bpmText == null || bpmText.contentEquals("")) {
                bpm = 90;
            } else {
                bpm = Integer.parseInt(bpmTextField.getText());
            }
            controller.setBPM(bpm);
        } else if (event.getSource() == increaseBPMButton) {
            controller.increaseBPM();
        } else if (event.getSource() == decreaseBPMButton) {
            controller.decreaseBPM();
        }
    }

    public void updateBPM() {
        if (model != null) {
            int bpm = model.getBPM();
            if (bpm == 0) {
                if (bpmOutputLabel != null) {
                    bpmOutputLabel.setText("offline");
                }
            } else {
                if (bpmOutputLabel != null) {
                    bpmOutputLabel.setText("Current BPM: " + model.getBPM());
                }
            }
        }
    }

    public void updateBeat() {
        if (beatBar != null){
            beatBar.setValue(100);
        }
    }
}

class BeatController implements ControllerInterface{
    BeatModelInterface model;
    DJView view;

    public BeatController(BeatModelInterface model){
        this.model = model;
        view = new DJView(this, model);
        view.createView();
        view.createControls();
        view.disableStopMenuItem();
        view.enableStartMenuItem();
        model.initialize();
    }

    public void start(){
        model.on();
        view.disableStopMenuItem();
        view.enableStopMenuItem();
    }

    public void stop(){
        model.off();
        view.disableStopMenuItem();
        view.enableStartMenuItem();
    }

    public void increaseBPM(){
        int bpm = model.getBPM();
        model.setBPM(bpm + 1);
    }

    public void decreaseBPM(){
        int bpm = model.getBPM();
        model.setBPM(bpm - 1);
    }

    public void setBPM(int bpm){
        model.setBPM(bpm);
    }
}

class HeartController implements ControllerInterface{
    HeartModelInterface model;
    DJView view;

    public HeartController(HeartModelInterface model){
        this.model = model;
        view = new DJView(this, new HeartAdapter(model));
        view.createView();;
        view.createControls();
        view.disableStopMenuItem();
        view.enableStartMenuItem();
    }

    public void start(){}
    public void stop(){}
    public void increaseBPM(){}
    public void decreaseBPM(){}
    public void setBPM(int bpm){}
}

public class DJTestDrive {
    public static void main(String[] args){
//        BeatModelInterface model = new BeatModel();
//        ControllerInterface controller = new BeatController(model);

        HeartModel heartModel = new HeartModel();
        ControllerInterface controller = new HeartController(heartModel);
    }
}