设计模式八—————观察者模式

观察者模式定义：观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使他们能够自己更新自己。
观察者模式初步理解：多个观察者同时观察同一个被观察者，被观察者状态发生变化时，会通知观察者，使得观察者内部的参数也相应改变。因为要通知被观察者，因此观察者内部要有被观察者对象的引用。因为有多个观察者，所有被观察者中要有一个集合来存放引用。因为状态发生变化时就要通知，所有发生变化时就要遍历这个集合，并调用观察者统一的更新方法，所以有必要抽象出一个观察者的更新方法。
code…

---

被观察者：

public class Flower {
    //被观察者的属性
    private int length;
    private String color;
    private ArrayList<Obser> arrayList=new ArrayList<>();//观察者集合
    public Flower(int length, String color) {
        this.length = length;
        this.color = color;
    }
    public int getLength() {
        return length;
    }
    public void change(int length) {
        this.length = length;
        this.Notify();
    }
    public String getColor() {
        return color;
    }
    public void change(String color) {
        this.color = color;
        this.Notify();
    }
    public void add(Obser obser)
    {
        arrayList.add(obser);
    }
    public void change(int length, String color) {
        this.length = length;
        this.color = color;
        this.Notify();
    }
    public void Notify()//通知观察者更新参数
    {
        Iterator it=arrayList.iterator();
        while(it.hasNext())
        {
            Obser obser=(Obser) it.next();
            obser.update(this);
        }
    }
}

被观察者是一朵花，有长度和颜色这两个属性。当这两个属性中的任何一个属性发生变化时，都会遍历观察者集合，传递当前对象，让观察者根据传入对象来更新自己观察的参数。
抽象的观察者类：

public abstract class Obser {
    private int length;
    private String color;

    public Obser(Flower flower) {
        flower.add(this);//将当前观察者添加到被观察者的集合当中。
    }
    public int getLength() {
        return length;
    }
    public void setLength(int length) {
        this.length = length;
    }
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public abstract void update(Flower flower);
    public abstract void show();
}

观察长度的观察者：

public class ObserLength extends Obser {
    public ObserLength(Flower flower) {
        super(flower);//告知观察者所要观察的对象
    }
    @Override public void update(Flower flower) {
       this.setLength(flower.getLength());//根据观察的对象来更新自己的参数。
    }
    public void show()
    {
        System.out.println("观察长度的结果---"+this.getLength());
    }
}

观察颜色的观察者与之类似。接下来看main方法：

public class Main {
    public static void main(String[] args) {
        Flower flower=new Flower(12,"blue");
        Obser obser1=new ObserLength(flower);
        Obser obser2=new ObserColor(flower);
        Obser obser3=new ObserAll(flower);
        flower.change(30);
        obser1.show();
        obser3.show();
        flower.change("red");
        obser2.show();
        obser3.show();
    }
}

先创建了被观察者，然后再创建观察者。创建观察者的时候要告知所要观察的对象，把观察者添加到这个对象的集合中。这一步在抽象的观察者类的构造方法中。观察者刚一创建，就被添加到集合中了。

总结：观察者模式所做的工作是在解除耦合。让耦合的双方都依赖于抽象，而不是依赖于具体。观察者模式只是对一个对象进行观察，反应器模式是对多个对象进行观察。在NIO中用的就是反应器模式。

上一篇

---The End---

下一篇