图解 head first 设计模式

个人笔记，比较粗糙。详细内容请参考《head first 设计模式》

strategy

• 基础：抽象、封装、多态、继承

• 原则

  • 封装变化：找出会变化的方面，把它们从不变的部分分离出来。
  • 多用组合、少用继承
  • 针对接口编程，不针对实现编程

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

  • 封装可互换的行为，然后使用委托来决定要采用哪一个行为。
  • 使用对象组合。

public class MiniDuckSimulator1 {

    public static void main(String[] args) {

        Duck mallard = new MallardDuck();
        mallard.performQuack();
        mallard.performFly();

        Duck model = new ModelDuck();
        model.performFly();
        model.setFlyBehavior(new FlyRocketPowered());
        model.performFly();

    }
}

Observer

• 原则

  • 为交互对象之间的松耦合设计二努力

• 定义：在对象之间定义一对多的依赖，这样一来，当一个对象改变状态，依赖它的对象都会收到通知，并自动更新。

  • 当某个状态被改变时，允许一群对象能被通知到。
  • 利用继承设计子类的行为，是在编译时静态决定的，而且所有的子类都会继承到相同的行为。然而，如果能利用组合的做法扩展对象的行为，就可以在运行时动态地进行扩展。

• 例子：新闻、订阅

public class WeatherStation {

    public static void main(String[] args) {
        WeatherData weatherData = new WeatherData();

        CurrentConditionsDisplay currentDisplay =
            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);
    }
}

java提供的观察者模式

decorator

• 原则

  • 对扩展开放，对修改关闭

• 定义：动态地将责任附加到对象上。想要扩展功能，装饰者提供有别于继承的另一种选择。

• 例子：I/O
  

factory

• 原则

  • 依赖抽象，不要依赖具体类。

• 定义：

  • 静态工厂方法：
  • 工厂方法：定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。（继承）

  • 抽象工厂方法：提供一本接口，用于创建相关或依赖对象的家族，而不需要置顶具体类。（组合）

  • 例子：实例化对象

静态工厂

工厂方法

public 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;
    }
}

抽象工厂方法

singleton

public class Singleton {
    private static Singleton uniqueInstance;

    private Singleton() {}

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

    // other useful methods here
    public String getDescription() {
        return "I'm a classic Singleton!";
    }
}

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

• 例子：threadpool、cache、registry

command

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

  • 好处：将‘发出请求的对象’和‘接受与执行这些请求的对象’分割开来。

• 例子：队列请求、日志请求、

public class RemoteControlTest {
    public static void main(String[] args) {
        SimpleRemoteControl remote = new SimpleRemoteControl();
        Light light = new Light();
        GarageDoor garageDoor = new GarageDoor();
        LightOnCommand lightOn = new LightOnCommand(light);
        GarageDoorOpenCommand garageOpen =
            new GarageDoorOpenCommand(garageDoor);

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

adapter

• 定义：
  
  • 适配器(adapter-pattern)：将一个类的接口，转换成客户期望的另一个接口。适配器让原来接口不兼容的类可以合作无间。对象适配器（组合）；类适配器（多重继承）
  • 外观(facade-pattern)：提供了一个统一的接口，用来访问子系统中的一群接口。外观定义了一个高层接口，让子系统更容易使用。

例子：迭代器
-

template

• 原则：

  • 只和朋友交谈
  • 别找我，我会找你

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

  • 使用继承

• 例子：用模板方法排序（comparable接口-compareTo）

iterator

• 原则：一个类应该只有一个引起变化的原因。
• 定义：
  
  • 迭代器：提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示。
  • 组合：允许你将对象组成树形结构来表现“整体、部分”的层次结构。组合能让客户以一致的方式处理个别对象和对象组合。

state

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

proxy

• 定义：为另一个对象提供一个替身或占位符来访问这个对象。