HeadFirst设计模式笔记(一)策略模式，观察者模式

1. 设计原则

1. 找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。
2. 针对接口编程，而不是针对实现编程。
3. 多样组合，少用继承。
4. 为了交互对象之间的松耦合设计而努力。
5. 类应该对扩展开放，而对修改封闭。

2. 设计模式

1. 策略模式

1.1 定义：

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

1.2 鸭子模拟器案例：

这里应用了前两个设计原则。不同鸭子会有不同的飞行行为，不同的鸭子会有不同的呱呱叫行为，这些是需要变化的代码，所以独立出来；把鸭子的飞行行为和呱呱叫行为分别抽象为两个行为接口，设计不同鸭子采用接口不同的实现类。

1.3 示例代码

fly行为
//  飞行接口 
public interface FlyBehavior {  
public void fly();  
}  
//  飞 
public class FlyWithWings implements FlyBehavior{  
public void fly() {  
        System.out.println("正在用翅膀飞行");  
    }  
}  
//  不飞 
public class FlyNoWay implements FlyBehavior{  
public void fly() {  
        System.out.println("不会飞");  
    }  
}  
//坐火箭飞 
public class FlyRocketPowered implements FlyBehavior{  
public void fly() {  
        System.out.println("坐火箭飞");  
    }  
}  
quack行为
//  叫接口 
public interface QuackBehavior {  
public void quack();  
}  
// 嘎嘎叫 
public class Quack implements QuackBehavior. {  
public void quack() {  
        System.out.println("嘎嘎叫");  
    }  
}  
//  吱吱叫 
public class Squeak implements QuackBehavior{  
public void quack() {  
        System.out.println("吱吱叫");  
    }  
}  
//  不叫 
public class MuteQuack implements QuackBehavior{  
public void quack() {  
        System.out.println("不会叫");  
    }  
} 
实现Duck类  
//  鸭子超类
public abstract class Duck {  
//  默认的行为 
FlyBehavior flyBehavior;  
    QuackBehavior quackBehavior;  

public Duck() {  
    }  
public void setFlyBehavior(FlyBehavior. fb) {  
        flyBehavior = fb;  
    }  
public void setQuackBehavior(QuackBehavior. qb) {  
        quackBehavior = qb;  
    }  
abstract void display();  
public void performFly() {  
        flyBehavior.fly();  
    }  
public void performQuack() {  
        quackBehavior.quack();  
    }  
public void swim() {  
        System.out.println("正在游泳~~");  
    }  
}  

//  野鸭  
     public class MallardDuck extends Duck {  
     public MallardDuck() {  
         quackBehavior = new Quack();  
                 flyBehavior = new FlyWithWings();  //这里也可以使用setFlyBehavior方法，下同！
     }  
     public void display() {  
         System.out.println("绿头鸭");  
     }  
}  
     //  红头鸭  
     public class RedHeadDuck extends Duck {  
     public RedHeadDuck() {  
         flyBehavior = new FlyWithWings();  
         quackBehavior = new Quack();  
     }  
     public void display() {  
         System.out.println("红头鸭");  
     }  
}  
     //  橡皮鸭  
    public class RubberDuck extends Duck {  
     public RubberDuck() {  
         flyBehavior = new FlyNoWay();  
         quackBehavior = new Squeak();  
     }  
     public void display() {  
         System.out.println("橡皮鸭");  
     }  
}  
     //模型鸭  
public class ModelDuck extends Duck {  
     public ModelDuck() {  
         flyBehavior = new FlyNoWay();  
         quackBehavior = new Quack();  
     }  
     public void display() {  
         System.out.println("模型鸭");  
     }  
}  

/*测试代码：*/

public class MiniDuckSimulator {  

public static void main(String[] args) {  

        MallardDuck    mallard = new MallardDuck();  
        RubberDuck    rubberDuckie = new RubberDuck();  
        RedHeadDuck    redHeadDuck = new RedHeadDuck();  

        ModelDuck    model = new ModelDuck();  

        mallard.performQuack();  
        rubberDuckie.performQuack();  
        redHeadDuck.performQuack();  

        model.performFly();      
        model.setFlyBehavior(new FlyRocketPowered());  
        model.performFly();  
    }  
}  

2. 观察者模式

2.1 定义：

观察者模式定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。

2.2 气象站发布气象布告栏订阅信息显示案例：

这里气象站是主题（Subject，或者叫做Observabler）类比于出版者，是事件发生的主体，布告栏是订阅者改称为观察者（Observer），是响应事情发生的主体。这里是一个一对多关系。模式定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新，这样的模式让主题和观察者之间松耦合。它体现了第四个原则：为了交互对象之间的松耦合设计而努力。

2.3.1 首先定义接口，实现这两个接口的类就是相应的主题类–气象搜集装置以及观察者类–对应气象发布版：

// 在主题接口中定义注册删除通知观察者三个方法
public interface Subject { 
    public void registerObserver(Observer o); 
    public void removeObserver(Observer o); 
    public void notifyObservers(); 
}
// 在观察者中，我们要求有一个方法：更新气象发布版的数据。
public interface Observer { 
    public void update(float temp, float humidity, float pressure); 
}
// 另外，每个布告板需要显示信息,定义第三个显示接口
public interface DisplayElement { 
    public void display(); 
}

2.3.2 接口实现以及测试

public class WeatherData implements Subject { 
    private ArrayList observers;//维护一个观察者列表 
    private float temperature; 
    private float humidity; 
    private float pressure; 
    public WeatherData() { 
        observers = new ArrayList(); //为了记住观察者而维护的列表，类比于报刊发行部门的订阅者列表 
    } 
    public void registerObserver(Observer o) { 
        observers.add(o); 
    } 
    public void removeObserver(Observer o) { 
        int i = observers.indexOf(o); 
        if (i >= 0) { 
            observers.remove(i); 
        } 
    } 
    public void notifyObservers() { //这个方法对所有注册的观察者进行通知 
        for (int i = 0; i < observers.size(); i++) { 
            Observer observer = (Observer)observers.get(i); 
            observer.update(temperature, humidity, pressure); //推数据 
        } 
    } 
    public void measurementsChanged() { //这个方法是对notifyObservers的封装 
        notifyObservers(); 
    } 
    public void setMeasurements(float temperature, float humidity, float pressure) { 
        this.temperature = temperature; 
        this.humidity = humidity; 
        this.pressure = pressure; 
        measurementsChanged();//这个方法会进而去通知所有的观察者 
    } 
    // other WeatherData methods here 
    public float getTemperature() { 
        return temperature; 
    } 
    public float getHumidity() { 
        return humidity; 
    } 
    public float getPressure() { 
        return pressure; 
    } 
}


/*我们再根据观察者接口实现多种气象发布版，这里只举出一个例子，其余大同小异：*/
public class CurrentConditionsDisplay implements Observer, DisplayElement { 
    private float temperature; 
    private float humidity; 
    private Subject weatherData;//维护一个主题的引用，注册观察者所用 
    public CurrentConditionsDisplay(Subject weatherData) { 
        this.weatherData = weatherData; 
        weatherData.registerObserver(this);//创建的时候就注册，这里也可以不进行这个，而使用 WeatherData 的registerObserver公有方法 
    } 
    public void update(float temperature, float humidity, float pressure) { //观察者留出的推送接口 
        this.temperature = temperature; 
        this.humidity = humidity; 
        display(); 
    } 
    public void display() { 
        System.out.println("Current conditions: " + temperature 
            + "F degrees and " + humidity + "% humidity"); 
    } 
}

/*我们测试一下这个程序：*/
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); 
    } 
}

2.3.3 java内置观察者模式

java内置的主题是一个类：Observable
java内置的观察者是接口：Observer