设计模式《三》_观察者模式

ゝ一世哀愁。 2021-11-26 17:42 242阅读 0赞

**定义：**

当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式属于行为型模式。

**关键代码：**在抽象类里有一个 ArrayList 存放观察者们。

**使用场景：**

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

![1556357-20190715133014553-1809891734.png][]

ISubject接口：

public interface ISubject {
        public void registerObserver(Observer observer);
        public void removeObserver(Observer observer);
        public void notifyObservers();
    }

NewsOffice：

public class NewsOffice implements ISubject{
    
        private List<Observer> observers = new ArrayList<>();
    
        public void newPaperCome(){
            this.notifyObservers();
        }
    
        @Override
        public void registerObserver(Observer observer) {
            this.observers.add(observer);
        }
    
        @Override
        public void removeObserver(Observer observer) {
            this.observers.remove(observer);
        }
    
        @Override
        public void notifyObservers() {
            for (Observer observer : observers){
                observer.update();
            }
        }
    }

**观察者Observer：**

public abstract class Observer  {
        public abstract void update();
    }

**　**

**观察者A：**

public class CustomerA extends Observer{
    
        @Override
        public void update() {
            System.out.println("客户A收到报纸!");
        }
    }

**观察者B：**

public class CustomerB extends Observer{
    
        @Override
        public void update() {
            System.out.println("客户B收到报纸!");
        }
    }

**测试类doSome:**

public class doSome {
    
        public static void main(String[] args) {
    
            ISubject office = new NewsOffice();
    
            CustomerA customerA = new CustomerA();
            CustomerB customerB = new CustomerB();
    
            office.registerObserver(customerA);
            office.registerObserver(customerB);
    
            ((NewsOffice) office).newPaperCome();
        }
    }

**输出:**

客户A收到报纸!
    客户B收到报纸!

**优点：** 1、观察者和被观察者是抽象耦合的。 2、建立一套触发机制。

**缺点：** 1、如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。 2、如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。 3、观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

JAVA提供的：

观察者：Observer

被观察者：Observable

![1556357-20190715142439641-1336326657.png][]

![1556357-20190715142452779-345836900.png][]

JDK自带的类，观察者的list为Vector,及考虑到了线程安全的编码。
     
     就这样吧。

转载于:https://www.cnblogs.com/recurision/p/11188760.html

[1556357-20190715133014553-1809891734.png]: /images/20211126/3859b1fd6dbc4491978243fe54959345.png
[1556357-20190715142439641-1336326657.png]: /images/20211126/7ac75a863aa445589a9554e713c7a8af.png
[1556357-20190715142452779-345836900.png]: /images/20211126/7f2ae16751b9407cbb78ae77cb56e811.png