设计模式——观察者模式

    HeadFirst中对观察者模式的定义:观察者模式定义了对象之间的一对多的依赖,这样一来,当一个状态发生变化时,它的所有依赖者都会收到通知并自动更新。

   松耦合:当两个对象时间松耦合,它们依然可以交互,但是不太清楚彼此的细节。

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

   有两种自动更细的方式,主题推送给每个观察者或者观察者从主题中拉取。

   Java中内置了观察者模式,可以很方便的写出代码。

   自己写了两个Demo,一个是自己实现,一个是借助Java中的实现。

  Demo1:

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.wxisme.observer;
 
import java.util.ArrayList;
import java.util.List;
 
/**
 * 主题接口
 * @author wxisme
 *
 */
 
public interface Subject {
    List<Observer> observerList = new ArrayList<>();
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObserver();
}

 

 

1
2
3
4
5
6
7
8
9
package com.wxisme.observer;
/**
 * 观察者接口
 * @author wxisme
 */
public interface Observer {
    void update(Subject subject);
 
}

 

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
package com.wxisme.observer;
/**
 * 具体的主题对象,实现主题接口
 * @author wxisme
 *
 */
public class ConcreteSubject implements Subject {
     
    private int state;
     
    @Override
    public void registerObserver(Observer observer) {
        ConcreteSubject.observerList.add(observer);
    }
     
    @Override
    public void removeObserver(Observer observer) {
        ConcreteSubject.observerList.remove(observer);
    }
    @Override
    public void notifyObserver() {
        for(int i=0; i<ConcreteSubject.observerList.size(); i++) {
            ConcreteSubject.observerList.get(i).update(this);
        }
    }
     
    public void changed() {
        this.notifyObserver();
    }
    public int getState() {
        return state;
    }
    //当具体的主题对象的状态改变时,会调用notify()方法,通知每个在此主题注册了的观察者。
    public void setState(int state) {
        this.state = state;
        this.changed();
    }
 
}

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package com.wxisme.observer;
/**
 * 具体的观察者,实现观察者接口。
 * @author wxisme
 *
 */
public class ConcreteObserver implements Observer {
    private int myState;
    @Override
    public void update(Subject subject) {
        setMyState(((ConcreteSubject)subject).getState());
        System.out.println("myState changed:" + myState);
    }
     
    public int getMyState() {
        return myState;
    }
 
    public void setMyState(int myState) {
        this.myState = myState;
    }
}

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package com.wxisme.observer;
/**
 * 测试观察者模式
 * @author wxisme
 */
public class Demo {
 
    public static void main(String[] args) {
        //一个主题对应多个观察者
        ConcreteSubject csbj = new ConcreteSubject();
        ConcreteObserver cobs1 = new ConcreteObserver();
        csbj.registerObserver(cobs1);
        ConcreteObserver cobs2 = new ConcreteObserver();
        csbj.registerObserver(cobs2);
        ConcreteObserver cobs3 = new ConcreteObserver();
        csbj.registerObserver(cobs3);
        //当主题的状态改变时,会通知每个观察者,每个观察者会做出相应的状态改变。
        csbj.setState(20);
        System.out.println("------------------");
        csbj.setState(400);
         
    }
 
}

 运行结果:

  myState changed:20
  myState changed:20
  myState changed:20
  ------------------
  myState changed:400
  myState changed:400
  myState changed:400

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.wxisme.javaobserver;
 
import java.util.Observable;
 
public class ConcreteSubject extends Observable {
    private int state;
     
    public int getState() {
        return state;
    }
    public void setState(int state) {
        this.state = state;
        setChanged();
        notifyObservers(state);
    }
}

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com.wxisme.javaobserver;
 
import java.util.Observable;
import java.util.Observer;
 
public class ConcreteObserver implements Observer {
    private int myState;
    @Override
    public void update(Observable obs, Object obj) {
        setMyState(((ConcreteSubject)obs).getState());
        System.out.println("myState changed:" + myState);
    }
     
    public void setMyState(int myState) {
        this.myState = myState;
    }
 
    public int getMyState() {
        return myState;
    }
}

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package com.wxisme.observer;
/**
 * 测试观察者模式
 * @author wxisme
 */
public class Demo {
 
    public static void main(String[] args) {
        //一个主题对应多个观察者
        ConcreteSubject csbj = new ConcreteSubject();
        ConcreteObserver cobs1 = new ConcreteObserver();
        csbj.registerObserver(cobs1);
        ConcreteObserver cobs2 = new ConcreteObserver();
        csbj.registerObserver(cobs2);
        ConcreteObserver cobs3 = new ConcreteObserver();
        csbj.registerObserver(cobs3);
        //当主题的状态改变时,会通知每个观察者,每个观察者会做出相应的状态改变。
        csbj.setState(20);
        System.out.println("------------------");
        csbj.setState(400);
         
    }
 
}

 运行结果:

myState changed:20
myState changed:20
myState changed:20
------------------
myState changed:400
myState changed:400
myState changed:400

 

posted @   Pickle  阅读(536)  评论(0编辑  收藏  举报
点击右上角即可分享
微信分享提示