Observer (Java) - Design Patterns学习笔记（3）

 观察者模式，就是观察者在被观察对象里注册自己的一个引用，当被观察对象发生观察者敏感的变化时，被观察对象发给注册的所有观察者发送消息（函数调用），观察者做出相应的响应。

观察者模式应用很多，比如说经常用到的事件响应。你总不能再起一个线程在那里傻傻不动地监听对象变化，最好的做法就是让对象发生敏感变化时主动给观察者发一个消息，这样就不会造成不必要的开销。

今天写了一个观察者的例子：
闹钟（被观察对象）响（发送消息），人（观察者）被惊醒（做出响应）。

程序清单：
Observer.java        //观察者接口
Subject.java        //被观察者接口
Person.java        //人 类
AlermClock.java      //闹钟 类
Test.java                //测试程序入口

Observer.java        //观察者接口

public interface Observer ...{
    //响应消息
    void notified(); 
}

Subject.java        //被观察者接口

import java.util.*;

public interface Subject ...{
    List<Observer> _obsList = new LinkedList<Observer>();
    //注册观察者
    void registry(Observer obs);
}

Person.java        //人 类

public class Person implements Observer ...{
    private String _name = null;
    
    public Person(String name) ...{
        this._name = name;
    }
    
    //响应消息
    public void notified() ...{
        System.out.println(_name+" is waked.");
    }
}

AlermClock.java      //闹钟 类

import java.util.*;

public class AlermClock implements Subject ...{
    
    List<Observer> _obsList = new LinkedList<Observer>();
    
    //注册观察者
    public void registry(Observer obs) ...{
        this._obsList.add(obs);
    }
    
    //观察者敏感事件
    public void alerm() ...{
        Iterator<Observer> i = _obsList.iterator();
        
        Observer obs = null;
        while(i.hasNext()) ...{
            obs = i.next();
            obs.notified();
        }
    }
}

Test.java                //测试程序入口

public class Test ...{
    
    public static void main(String[] args) ...{
        
        AlermClock clock = new AlermClock();
        Person nyzhl = new Person("Zhao Hongliang");
        Person Tom = new Person("Tom");
        Person Lucy = new Person("Lucy");
        
        //注册观察者
        clock.registry(nyzhl);
        clock.registry(Tom);
        clock.registry(Lucy);
        
        //观察者敏感时间
        clock.alerm();
    }
}

运行结果：

Zhao Hongliang is waked.
Tom is waked.
Lucy is waked.

在C#中运用观察者模式会有更好的办法-委托，类的耦合性更低。困了，明天再写！