（14）老板回来，我不知道——观察者模式

观察者模式

定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。（摘抄）

观察者模式可以大大的降低类与类之间的耦合，同时又能保持一些对象改变的一致性。

观察者模式把相互调用的类，抽象成了两个部分，它们之间互不干扰，可以各自独立的改变和使用，其中一个部分依赖于另一个部分的抽象，当一个部分改变时，可以通知另一个部分及时发生改变。

import java.util.ArrayList;
abstract class Subject{
    private ArrayList<Observer> list = new ArrayList<Observer>();
    private String subjectState;
    public void Attach(Observer observer){
    }

    public void Detach(Observer observer){
    }

    public void Notify(){
        for (Observer o : list){
            o.update();
        }
    }

}

interface Observer{
    void update();
}

class ConcreteSubject1 extends Subject{
    public void Notify(){
        System.out.println("abcd");
    }
}

class ConcreteSubject2 extends Subject{
    public void Notify(){
        System.out.println("bcde");
    }
}

class ConcreteObserver1 implements Observer{
    private Subject subject;
    public ConcreteObserver1(Subject subject){
        this.subject = subject;
    }
    @Override
    public void update(){
        // TODO Auto-generated method stub
        System.out.println("1"+subject);
    }
}

class ConcreteObserver2 implements Observer{
    private Subject subject;
    public ConcreteObserver2(Subject subject){
        this.subject = subject;
    }
    @Override
    public void update() {
        // TODO Auto-generated method stub
        System.out.println("2"+subject);
    }
}

class Client{
    public static void main(){
        Subject subject = new ConcreteSubject1();
        subject.Attach(new ConcreteObserver1(subject));
        subject.Attach(new ConcreteObserver2(subject));
        subject.Notify();
        //更换主题类
        // Subject subject = new ConcreteSubject2();
        // subject.Attach(new ConcreteObserver1(subject));
        // subject.Attach(new ConcreteObserver2(subject));
        // subject.Notify();
    }
}

话说我感觉这一章这本书好像没怎么讲明白，所以感觉自己说呢也没有说明白，不过差不多理解什么意思了，我感觉树上前面的代码完全就还是耦合的，还是在ConcreteObserver类中调用了ConcreteSubject类，它没有用到抽象的类，我感觉可能书上弄错了。

观察者模式优点：就是类与类之间依赖的是抽象对象，而不是具体对象，当具体对象更改时对于整个代码是没有影响的，同时是多个对象依赖于一个抽象对象，当对象状态发生变化时通知其它对象发生相应的改变比较方便

观察者模式缺点：抽象通知者依赖的是抽象观察者，当抽象观察者产生的时间在抽象通知者之后，那么就没有update方法给抽象观察者调用了。

委托

用委托的方法可以解除掉观察者模式的缺点，在c＃中有委托这种用法，在java中就要使用到动态代理，需要理一理思路，查一查文章，等下再写一篇专门说java动态代理的吧

文章导航