设计模式--观察者模式

设计模式--观察者模式

1、观察者模式

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

2、观察者模式的结构

• 角色

  • 主题（Subject）:主题是一个接口，该接口规定了具体主题需要实现的方法，比如添加，删除观察者以及通知观察者的方法。

  • 观察者（ObServer）: 观察者是一个接口，该接口规定了具体观察者用来获得数据的方法。

  • 具体主题（ConcreteSubject）:具体主题是实现主题接口的类的一个实例，该实例包含观察者关心的数据，而且这些数据可能经常发生变化。具体主题需要使用一个集合来存放观察者的引用，以便数据变化时通知具体的观察者。

  • 具体观察者（ConreteObserver）:具体观察者是实现观察者接口的类的一个实例。具体观察者包含具体主题的引用，以便让具体主题将自己添加到具体主题的集合中，使自己成为具体主题的观察者，或者从具体主题的集合中将自己删除，不成为具体主题的观察者。

• UML图

　　

3、观察者模式举例

　主题接口：Subject.java

 1 package com.nick.pattern.observer;
 2 
 3 import java.util.ArrayList;
 4 
 5 /**
 6  * @ 主题接口:定义了观察者数组（存放观察者的信息）和抽象方法
 7  * @author nick
 8  *
 9  */
10 public interface Subject {　　
11    ArrayList<Observer> observers =null;
12　　 void attach(Observer obs); 
13    void detach(Observer obs); 
14    void cry();　　//相当于notify()通知方法 
15 }

 观察者接口：Observer.java

package com.nick.pattern.observer;
/**
 * @ 观察者接口
 * @author nick
 */
public interface Observer {
    void response();　//相当于update()方法　
}

 具体主题类：Cat.java

package com.nick.pattern.observer;

import java.util.ArrayList;

/**
 * @ 具体主题：猫（老鼠和狗是观察者，他们通过观察猫的行为，做出反应）
 * @author nick
 *
 */
public class Cat implements Subject {
    ArrayList<Observer> observers = new ArrayList<Observer>();
    
    @Override
    public void attach(Observer obs) {
        observers.add(obs);
    }

    @Override
    public void detach(Observer obs) {
        observers.remove(obs);    
    }

    @Override
    public void cry() {    //通知方法
        System.out.print("猫叫:");
        System.out.println("喵喵喵");
        for(Observer obs:observers) {
            obs.response();
        }
    }
}

具体观察者：Dog.java

package com.nick.pattern.observer;
/**
 * @ 具体观察者: 狗
 * @author nick
 *
 */
public class Dog  implements Observer{

    @Override
    public void response() {
        System.out.print("狗叫：");
        System.out.println("汪汪汪");
    }

}

具体观察者：Mouse.java

package com.nick.pattern.observer;
/**
 * @ 具体观察者：老鼠
 * @author nick
 *
 */
public class Mouse implements Observer{

    @Override
    public void response() {
        System.out.print("老鼠跑：");
        System.out.println("跑跑跑");
    }

}

主程序：Application.java

package com.nick.pattern.observer;
/**
 * @ 主程序
 * @author nick
 *
 */
public class Application {

    public static void main(String[] args) {
            Subject cat = new Cat();
            Observer dog = new Dog();
            Observer mouse = new Mouse();
            cat.attach(dog);
            cat.attach(mouse);
            
            cat.cry();//触发通知方法
    }

}

运行结果：

　　

 4、观察者模式的优缺点

• 优点1： 具体主题和观察者是松耦合的关系。由于主题接口仅仅依赖与观察者接口，因此具体主题只是知道他的观察者是实现观察者接口的某个类的实例，但不需要知道是哪个类。
• 优点2：具体观察者只需要知道它依赖的主题是实现主题接口的某个实例即可，不需要知道具体是哪个类。
• 优点3：观察者模式满足“开-闭”原则。主题接口(Subject)仅仅依赖于观察者接口（Observer）。这样具体主题的类也仅仅依赖于观察者接口，增加新的实现观察者接口的类，不必修改创建具体主题的类的代码：
  • 　　新增加一个观察者Pig.java

  • package com.nick.pattern.observer;
    /**
     * @ 新增的观察者Pig
     * @author nick
     */
    public class Pig implements Observer{
    
        @Override
        public void response() {
            System.out.println("猪叫：");
            System.out.println("咯咯咯");
        }
    
    }

  • 只需要在主程序中添加这两行代码
  • 
  •