策略模式和观察者模式

发表于 | 更新于: | 分类于 ，

为什么要设计模式

软件开发中，我们花费更多的时间在需求变化和维护项目上，想更好得应对变化需要建立弹性的，可维护、可应对变化的设计。而知道抽象、继承、多态，并不能马上成为面向对象设计者，设计模式正是告诉我们如何组织类和对象以解决某种问题，所以需要设计模式。

其实我们正在使用的框架封装了很多设计模式，但是我们感觉不到。可以先让设计模式进入你的脑海，再尝试使用。

策略模式

现在有个模拟鸭子的游戏，游戏中出现各种鸭子，比如一边游泳，一边呱呱叫，每个鸭子的外形不同。使用面向对象（OO）技术，设计类图如下

duck1

需求变动，有些鸭子要添加飞的特性，会飞的特性代码添加在哪里呢？

  • 父类 Duck 的实现代码中，这样会导致全部鸭子都会飞，明显不行。
    • 解决方案，可以把 fly() 覆盖掉，使得鸭子不会飞。但也有鸭子会飞不会叫，采用同样的方法覆盖 quack()
    • 缺点，很难知道鸭子全部行为、代码在多个子类中重复
  • 利用接口，把 fly() quack() 方法接口出去
    • 缺点，此时行为代码写在鸭子子类中，代码无法复用，如果有48个鸭子都要稍微修改一下飞行的行为，很容易出错

duck1

上面两种方式都不能解决问题，那是因为我们没有遵循设计原则

  • 找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。

这样我们可以把飞和叫 的行为抽出成类，独立出去。类图如下

duck1

现在父类Duck 中只要 FlyBehaior QuackBehavior 两个行为接口引用就行了，在利用多态特性去调用飞和叫的方法，而且具体的方法实现也不会出现在Duck 或者Duck 子类中。

duck1

Duck 代码实现如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
public abstract class Duck{
    FlyBehavior flyBehavior;
    QuackBehavior quackBehavior;
    
    public Duck(){
        
    }
    
    public void performFly(){
        flyBehavior.fly();
    }
    
    public void performQuack(){
        quackBehavior.quack();
    }
    
    public void swim(){
        // .....
    }
}

// 飞行为
public interface FlyBehavior{
    public void fly{};
}

public class FlyWithWings implements FlyBehavior {
    public void fly(){
        //...
    }
}

public class FlyNoWay implements FlyBehavior {
    public void fly(){
        // ...
    }
}

// 实现 一个鸭子
public class MallardDuck extends Duck {
    public MallardDuck(){
        quackBehavior = new Quack();
        flyBehavior = new FlyWithWings();
    }
    
    public void dispaly(){
        // ...
    }
}

这样就可以很方便添加飞行为的其他实现，这时全部类图

duck1

当然Duck 也可以提供set flyBehavior实现类的对象，使得鸭子对象在运行时能改变自己飞的行为形式

1
2
3
public void setFlyBehavior(FlyBehavior fb){
    flyBehavior = fb;
}

策略者模式：定义算法族，分别封装起来，让他们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。其实在 重构 优化switch/case 语句中使用的就是策略模式。

观察者模式

现在有一个气象站，它是获取湿度、温度、气压数据的物理装置，WeatherData追踪气象站的数据变化，并且更新到报告班板，如图

duck1

需求：

  1. WeatherData 类有getter 方法，可以取得温度、湿度、气压、三个测量值。当测量数据发送变化时，WeatherData measurementsChanged() 方法就会被调用（先不管它是如何被调用的，只要记住一点数据变化会调用此方法）
  2. 需要实现三个布告板，目前状况布告、气象统计布告、天气预报布告；并且系统需可扩展，实现让其他开发人员建立定制的布告板，用户可以随便添加或者删除 任何布告板。

duck1

一般我们是这样实现的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class WeatherData {
    // 实例变量声明
    pubic void measuremetnsChanged(){
        float temp = getTemperature();
        float humidity = getHumidity();
        float pressure = getPressure();
        
        currentConditionsDisplay.update(temp, humidity, pressure);
        statisticsDisplay.update(temp, humidity, pressure);
        forecastDisplay.update(temp, humidity, pressure);
    }
    
    // 这里WeatherData 其他方法
}

这样实现由缺点

  • 对于每个新的布告板，我们都得修改代码，我们尚未封装改变的部分
  • 布告板没有实现一个共同的 接口，至少update 看来参数没有发生变化
  • 我们无法在运行时动态地添加、删除布告板

利用观察者模式来设计，观察者模式就类似在生活中我们 向杂志社订阅或者取消订阅报纸、杂志。结合模型对象的编程思想，杂志社需要提供 订阅、取消订阅、通知用户的方法，而订阅者肯定要提供一个 让杂志社联系上自己的方法。联系上面的需求，画出类图

duck1

所以我们可以把实现上面需求的类图设计为

duck1

实现代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
public interface Subject {
    public void registerObserver(Observer o);
    public void removeObserver(Observer o);
    public void notifybservers();
}

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

public interface DisplayElement{
    public void display();
}

// 实现 weatherData
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){
            observer.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();
   }
}

 // 创建布告板
 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);
    }
    
    public void update (float temperature, float humidity, float pressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        display();
    }
    
    public void display(){
      // ....
    }
}

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

欢迎大家给我留言，提建议，指出错误，一起讨论学习技术的感受！

-------------本文结束感谢您的阅读-------------
Donate comment here