设计模式之——观察者模式（一）

/* 
* 观察者模式 
* 定义对象间的一种一个(Subject)对多(Observer)的依赖关系，当一个对象的状态发送改变时，所以依赖于它的 
* 对象都得到通知并被自动更新 
* 
* 当然，MVC只是Observer模式的一个实例。Observer模式要解决的问题为： 
* 建立一个一（Subject）对多（Observer）的依赖关系，并且做到当“一”变化的时候， 
* 依赖这个“一”的多也能够同步改变。最常见的一个例子就是：对同一组数据进行统计分析时候， 
* 我们希望能够提供多种形式的表示（例如以表格进行统计显示、柱状图统计显示、百分比统计显示等）。 
* 这些表示都依赖于同一组数据，我们当然需要当数据改变的时候，所有的统计的显示都能够同时改变。 
* Observer模式就是解决了这一个问题。 
* 
* 适用性： 
* 1. 当一个抽象模型有两个方面，其中一个方面依赖于另一方面 
* 将这两者封装成独立的对象中以使它们可以各自独立的改变和服用 
* 
* 2. 当对一个对象的改变需要同时改变其他对象，而不知道具体有多少对象有待改变 
* 
* 3. 当一个对象必须通知其它对象，而它又不能假定其它对象是谁 
* 
* 参与者： 
* 1. Subject（目标） 
* 目标知道它的观察者，可以有任意多个观察者观察同一个目标 
* 提供注册和删除观察者对象的接口 
* 
* 2. Observer（观察者） 
* 为那些在目标发生改变时需获得通知的对象定义个更新的接口 
* 
* 3. ConcreteSubject（具体目标） 
* 将有关状态存入各ConcreteObserver对象 
* 当它的状态发送改变时，向它的各个观察者发出通知 
* 
* 4. ConcreteObserver（具体观察者） 
* 维护一个指向ConcreteObserver对象的引用 
* 存储有关状态，这些状态应与目标的状态保持一致 
* 实现Observer的更新接口是自身状态与目标的状态保持一致 
* 
* 
* */ 
*

实现：男生是观察者，女生是被观察者，当女生心情好的时候，会被男生观察到，然后采取把妹措施；

public abstract class Boy {//抽象观察者

    public abstract void action(String str);


}
 
 
1
2
3
4
5
6
 
 
1
2
3
4
5
6

具体观察者：

public class HandsomeBoy extends Boy{

    @Override
    public void action(String str) {

        System.out.println("girl "+str+" 我是帅哥，我要跟她约会去");
    }

}
 
 
1
2
3
4
5
6
7
8
9
 
 
1
2
3
4
5
6
7
8
9

public class UglyBoy extends Boy{

    @Override
    public void action(String str) {
        System.out.println("girl "+str+" 我是丑男，我要约她吃饭");

    }

}
 
 
1
2
3
4
5
6
7
8
9
 
 
1
2
3
4
5
6
7
8
9

抽象主题角色

public interface Girl{//被观察者

    public void addWatcher(Boy boy);

    public void removeWatcher(Boy boy);

    public void notifyWatchers(String str);
}
 
 
1
2
3
4
5
6
7
8
 
 
1
2
3
4
5
6
7
8

具体主题角色

public class BeautifulGirl implements Girl {

    private List<Boy> boysList = new ArrayList<Boy>();

    @Override
    public void addWatcher(Boy boy) {
        if (boy == null) {
            throw new IllegalArgumentException("the boy is null");
        }
        synchronized (boysList) {
            if (boysList.contains(boy)) {
                throw new IllegalArgumentException("the boy " + boy + " has been registered");
            }
            boysList.add(boy);
         }
    }

    @Override
    public void removeWatcher(Boy boy) {
        if (boy == null) {
            throw new IllegalArgumentException("the boy is null");
        }
        synchronized (boysList) {
            int index = boysList.indexOf(boy);
            if (index == -1) {
                throw new IllegalArgumentException("the boy " + boy + " was not registered");
            }
            boysList.remove(index);
         }
    }

    @Override
    public void notifyWatchers(String str) {
        synchronized (boysList) {
            for (Boy boy : boysList) {
                boy.action(str);
            }
        }

    }

}
 
 
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
 
 
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

测试：

public class Test {
public static void main(String[] args) {
    Girl girl = new BeautifulGirl();
    girl.addWatcher(new HandsomeBoy());
    girl.addWatcher(new UglyBoy());
    girl.notifyWatchers("我今天有时间");
}
}
 
 
1
2
3
4
5
6
7
8
 
 
1
2
3
4
5
6
7
8

输出： 
girl 我今天有时间 我是帅哥，我要跟她约会去 
girl 我今天有时间 我是丑男，我要约她吃饭

观察者模式Java已经做了封装，

如果要想实现观察者模式，则必须依靠java.util包中提供的Observable类和Observer接口。

class House extends Observable{ // 表示房子可以被观察  
    private float price ;// 价钱  
    public House(float price){  
        this.price = price ;  
    }  
    public float getPrice(){  
        return this.price ;  
    }  
    public void setPrice(float price){  
        // 每一次修改的时候都应该引起观察者的注意  
        super.setChanged() ;    // 设置变化点  
        super.notifyObservers(price) ;// 价格被改变  
        this.price = price ;  
    }  
    public String toString(){  
        return "房子价格为：" + this.price ;  
    }  
};   
class HousePriceObserver implements Observer{  
    private String name ;  
    public HousePriceObserver(String name){ // 设置每一个购房者的名字  
        this.name = name ;  
    }  
    public void update(Observable o,Object arg){  
        if(arg instanceof Float){  
            System.out.print(this.name + "观察到价格更改为：") ;  
            System.out.println(((Float)arg).floatValue()) ;  
        }  
    }  
};  
public class ObserDemo01{  
    public static void main(String args[]){  
        House h = new House(1000000) ;  
        HousePriceObserver hpo1 = new HousePriceObserver("购房者A") ;  
        HousePriceObserver hpo2 = new HousePriceObserver("购房者B") ;  
        HousePriceObserver hpo3 = new HousePriceObserver("购房者C") ;  
        h.addObserver(hpo1) ;  
        h.addObserver(hpo2) ;  
        h.addObserver(hpo3) ;  
        System.out.println(h) ; // 输出房子价格  
        h.setPrice(666666) ;    // 修改房子价格  
        System.out.println(h) ; // 输出房子价格  
    }  
};

运行结果： 
房子价格为：1000000.0 
购房者C观察到价格更改为：666666.0 
购房者B观察到价格更改为：666666.0 
购房者A观察到价格更改为：666666.0 
房子价格为：666666.0