16、设计模式(行为型)之观察者模式

电玩女神 2022-05-10 10:44 159阅读 0赞

### 作用 ###

*  定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

### 何时使用 ###

*  一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知，进行广播通知。

### 优点 ###

1.  观察者和被观察者是抽象耦合的。
2.  建立一套触发机制。

### 实例 ###

*  自己创建
    
        /**
         * @Author: create_By: chenxin
         * @Data:Created in 2018/9/25 17:15
         * @Version:
         * @Acton:
         */
        public interface Observer {
        
            void update(Subject subject);
        }
    
        /**
         * @Author: create_By: chenxin
         * @Data:Created in 2018/9/25 17:16
         * @Version:
         * @Acton:
         */
        public class Subject {
        
            protected List<Observer> list = new ArrayList<>();
        
            public void registerObserver(Observer observer){
                list.add(observer);
            }
        
            public void removeObserver(Observer observer){
                list.remove(observer);
            }
        
            //通知所有的观察者更新状态
            public void notifyAllObserver(){
                for (Observer observer : list) {
                    observer.update(this);
                }
            }
        }
    
        /**
         * @Author: create_By: chenxin
         * @Data:Created in 2018/9/25 17:22
         * @Version:
         * @Acton:
         */
        public class ConreteSubject extends Subject {
        
            private int state;
        
            public int getState() {
                return state;
            }
        
            public void setState(int state) {
                this.state = state;
                this.notifyAllObserver();
            }
        }
    
        /**
         * @Author: create_By: chenxin
         * @Data:Created in 2018/9/25 17:29
         * @Version:
         * @Acton:
         */
        public class ObserverA implements Observer {
        
            private int myState;        //myState需要跟目标对象的state值保持一致
            @Override
            public void update(Subject subject) {
                myState = ((ConreteSubject)subject).getState();
            }
        
            public int getMyState() {
                return myState;
            }
        
            public void setMyState(int myState) {
                this.myState = myState;
            }
        }
    
        /**
         * @Author: create_By: chenxin
         * @Data:Created in 2018/9/25 16:02
         * @Version:
         * @Acton:
         */
        public class TestObserverDemo {
            public static void main(String[] args){
                test1();
            }
        
            public static void test1(){
                //创建主题
                ConreteSubject subject = new ConreteSubject();
        
                //创建多个观察者
                ObserverA ob1 = new ObserverA();
                ObserverA ob2 = new ObserverA();
                ObserverA ob3 = new ObserverA();
        
                //注册所有的观察者
                subject.registerObserver(ob1);
                subject.registerObserver(ob2);
                subject.registerObserver(ob3);
        
                //设置状态
                subject.setState(3000);
        
                //
                System.out.println(ob1.getMyState());
                System.out.println(ob2.getMyState());
                System.out.println(ob3.getMyState());
        
                System.out.println("#====================?====================");
                //设置状态
                subject.setState(30);
        
                //
                System.out.println(ob1.getMyState());
                System.out.println(ob2.getMyState());
                System.out.println(ob3.getMyState());
            }
        }
    
     
 *  根据系统提供的API创建
    
        import java.util.Observable;
        import java.util.Observer;
        
        /**
         * @Author: create_By: chenxin
         * @Data:Created in 2018/9/25 18:51
         * @Version:
         * @Acton:
         */
        public class ObserverA implements Observer {
        
            private int myState;
        
            @Override
            public void update(Observable o, Object arg) {
                myState = ((ConcreteSubject)o).getState();
            }
        
            public int getMyState() {
                return myState;
            }
        
            public void setMyState(int myState) {
                this.myState = myState;
            }
        }
    
        import java.util.Observable;
        
        /**
         * @Author: create_By: chenxin
         * @Data:Created in 2018/9/25 18:41
         * @Version:
         * @Acton:
         */
        public class ConcreteSubject extends Observable {
        
            private int state;
        
            public void set(int s){
                state = s;          //对象 目标发生了改变
        
                setChanged();       //表示目标对象已经做了更改
        
                notifyObservers(state); //通知所有的观察者
            }
        
            public int getState() {
                return state;
            }
        
            public void setState(int state) {
                this.state = state;
            }
        }
    
        /**
         * @Author: create_By: chenxin
         * @Data:Created in 2018/9/25 18:30
         * @Version:
         * @Acton:
         */
        public class TestObserverDemo{
        
            public static void main(String[] args){
                test1();
            }
        
            public static void test1(){
                //创建目标对象
                ConcreteSubject subject = new ConcreteSubject();
        
                //创建观察者
                ObserverA ob1 = new ObserverA();
                ObserverA ob2 = new ObserverA();
                ObserverA ob3 = new ObserverA();
        
                //添加到目标对象的容器中
                subject.addObserver(ob1);
                subject.addObserver(ob2);
                subject.addObserver(ob3);
        
                //改变subject对象的状态
                subject.set(20000);
        
                //观察者的状态发生了变化
                System.out.println(subject.getState());
                System.out.println(subject.getState());
                System.out.println(subject.getState());
        
                //改变subject对象的状态
                subject.set(50000);
        
                //观察者的状态发生了变化
                System.out.println(subject.getState());
                System.out.println(subject.getState());
                System.out.println(subject.getState());
        
            }
        }

### 关系图结构图 ###

*  自己创建的  
    ![70][]
 *  系统API创建的  
    ![70 1][]

[70]: /images/20220510/814098cf2a8849259a5e6b08384d5f83.png
[70 1]: /images/20220510/79b5862132e14066b54718a31ea66b29.png