设计模式学习笔记（2）：观察者模式（1）

       观察者模式是一个很重要的设计模式。
       那么什么是观察者模式呢？
     《Head First》中的定义：  观察者模式定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。
       在观察者模式中，主要有两个角色，一个是主题对象（Subject/Observable），另一个是观察者对象（Observer）。在模式中有一个主题对象，有多个观察者对象。观察者对象依赖于主题对象。
       



    如上图所示，四个observer依赖于Subject，当Subject的状态发生改变，将会自动通知observer。这里提供一种观察者模式的实现方式：
    


      Subject只知道观察者实现了某个接口Observer，主题不需要知道观察者的具体类是什么，实现细节是什么。主题唯一依赖的就是实现Observer接口的对象列表，所以我们可以在运行时增加，删除，更换观察者。主题不受任何影响。这样建立了交互对象的松耦合设计。
       我们设想一个场景：你是一次自由行的组织者（Organizer），你需要统计此次自由行的人数（travelerNum），前往地点（terminal）及其相关信息（information），然后你获取了信息，你要实时通知成行的其他成员（Traveler），联系车辆（Driver）。在这里，我们的Organizer就是Subject，我们的Traveler和Driver就是Observer。需要传递的消息有travelerNum,terminal和information。
        Subject接口：public interface Observable {
//注册
public void registerObserver(Observer o);
//删除
public void removeObserver(Observer o);
//通知
public void notifyObservers();
}
        Observer接口：public interface Observer {
//更新相关信息
public void update(int travelerNum,String terminal,String information);
}
我们再添加一个，进行操作的接口TravelPrepare()

public interface TravelPrepare {
void doPrepare();
}

Organizer类去实现Subject也就是Observable接口public class Organizer implements Observable {
//用于存放observer的List
private ArrayList observers;
//旅客人数
private int travelerNum;
//目的地
private String terminal;
//相关信息
private String information;

//构造器，要先new observers否则会空指针
public Organizer(){
observers = new ArrayList();
}

//有新的
4000
观察者加入，例如：加入了新的同行者
@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 (int i = 0;i < observers.size();i++){
Observer observer = (Observer) observers.get(i);
observer.update(travelerNum,terminal,information);
}
}

//更新旅行信息
public void setTravelInformation(int travelerNum,String terminal,String information){
this.travelerNum = travelerNum;
this.information = information;
this.terminal = terminal;
notifyObservers();

}
}一个Driver类和一个Traveler类去实现Observer接口public class Traveler implements Observer,TravelPrepare {

//旅客人数
private int travelerNum;
//目的地
private String terminal;
//相关信息
private String information;
//主题
private Observable organizer;

public Traveler(Observable organizer) {
this.organizer = organizer;
organizer.registerObserver(this);
}

@Override
public void update(int travelerNum, String terminal, String information) {
this.travelerNum = travelerNum;
this.terminal = terminal;
this.information = information;
doPrepare();
}

@Override
public void doPrepare() {
System.out.println("我已知悉这次旅行有"+travelerNum+"人，前往"+terminal+"，其他相关信息有"+information);
}
}

public class Driver implements Observer,TravelPrepare  {
//旅客人数
private int travelerNum;
//目的地
private String terminal;
//相关信息
private String information;
//主题
private Observable organizer;

public Driver(Observable organizer) {
this.organizer = organizer;
organizer.registerObserver(this);
}

@Override
public void update(int travelerNum, String terminal, String information) {
this.travelerNum = travelerNum;
this.terminal = terminal;
this.information = information;
doPrepare();
}

@Override
public void doPrepare() {
System.out.println("我将准备"+travelerNum+"座位的车辆，将前往"+terminal);
}
}

最后模拟测试public class TravelSimulator {
public static void main(String[] args) {
Organizer organizer = new Organizer();
Traveler traveler = new Traveler(organizer);
Driver driver = new Driver(organizer);

organizer.setTravelInformation(10,"九华山","安徽");
organizer.setTravelInformation(30,"峨眉山","四川");
}
}结果



观察者模式的优点：
1.因为它是松耦合的所以极易扩展。
2.建立了一套触发机制，可以看到是链式的触发方式，但是如果对象太多，这又会给性能造成很大的负担。

应用场景：
1、一个抽象模型有两个方面，其中一个方面依赖于另一个方面。将这些方面封装在独立的对象中使它们可以各自独立地改变和复用。
2、一个对象的改变将导致其他一个或多个对象也发生改变，而不知道具体有多少对象将发生改变，可以降低对象之间的耦合度。
3、一个对象必须通知其他对象，而并不知道这些对象是谁。
4、需要在系统中创建一个触发链，A对象的行为将影响B对象，B对象的行为将影响C对象……，可以使用观察者模式创建一种链式触发机制。