设计模式--观察者模式

1.定义

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

观察者模式提供了一种对象设计，让主题和观察者之间松耦合。

2.自定义实现观察者模式代码示例

a.新建Observer接口类以及实现类

public interface Observer {
public void update();
}

public class AndroidObserver implements Observer {
@Override
public void update() {
System.out.println("Android observer update");
}

}

public class IosObserver implements Observer {

@Override
public void update() {

System.out.println("Ios observer update");
}

}

public class WebObserver implements Observer {

@Override
public void update() {
        System.out.println("web page observer update");
}

}

b.新建主题接口以及实现类

public interface Subject {

public void addObserver(Observer o);
public void removeObserver(Observer o);
public void notifyObserver();

}

public class HealthSubject implements Subject {

private ArrayList<Observer> observers; 


public HealthSubject(){
observers = new ArrayList<Observer>();
}
@Override
public void addObserver(Observer o) {
observers.add(o);
}


@Override
public void removeObserver(Observer o) {
        observers.remove(o);
}


@Override
public void notifyObserver() {


for(int i=0;i<observers.size();i++){
observers.get(i).update();
}
}

public void beginUpdate(){
notifyObserver();
}


}

c.新建测试代码：

public class MainTest {

public static void main(String[] args) {
//定义3个观察者
Observer android = new AndroidObserver();
Observer ios = new IosObserver();
Observer web = new WebObserver();
//定义一个主题
HealthSubject subject = new HealthSubject();
                //添加观察者到主题
subject.addObserver(android);
subject.addObserver(ios);
subject.addObserver(web);
subject.beginUpdate();

    }

}

3. java内置的观察者模式代码示例

java API有内置的观察者模式，java.util包包含最基本的Observal类和Observer接口。

实例代码如下：

public class MyObservable extends Observable{

public void notifyOb(){
setChanged();
notifyObservers();
}

}

public class ObOne implements java.util.Observer {

@Override
public void update(Observable o, Object arg) {
System.out.println("ObOne update invoke");
}

}

public class ObTwo implements java.util.Observer{


@Override
public void update(Observable o, Object arg) {
        System.out.println("ObTwo update invoke");
}

}

测试代码：

public class MainTest {


public static void main(String[] args) {

java.util.Observer o1 = new ObOne();
java.util.Observer o2 = new ObTwo();
MyObservable mysubject = new MyObservable();
mysubject.addObserver(o1);
mysubject.addObserver(o2);
mysubject.notifyOb();
}

}

Observable = 可观察者 = subject

Observer = 观察者 

可观察者送出通知步骤:

a. 调用setChanged()方法，标记状态已改变的事实。

b. 调用两种notifyOvbervers()方法中的一个

    notifyObservers()或者 notifyObservers(Object arg)   //arg参数为需要传递给观察者的数据对象

观察者接收通知

   update(Observable o, Ojbect arg)

   Observable可观察者，即主题subject，让观察者知道是哪个主题通知它的

    arg正是可观察者通过notifyObservers(Object arg)传入的数据对象

java内置源码大致如下：

setChanged(){

    changed = true;

}

notifyObservers(Object arg){

    if(changed){

        //call update()

        changed = false;

    }

}

notifyObservers(){

    notifyObservers(null);

}

故继承Observable的可观察者（主题类），在通知观察者（调用notifyObservers）之前，必须调用setChanged标记状态改变，否则观察者不能收到通知.

java内置观察者模式的不足： java.util.Observable是一个类，违背了OO设计原则，针对接口编程。setChanged()方法被定义成protected，所以除非继承Observable，否则无法创建Obsevable实例并组合到自己的对象中来。