Java观察者模式，

Java观察者模式，

观察者模式
观察者模式定义了对象间的一对多依赖关系，让一个或者多个观察者对象观察一个主题对象。
当主题对象的状态发生变化时，系统通知所有的依赖于才对想的观察者对象，从而使得观察者对象能够自动更新。
在观察者模式中，被观察的对象常常也被称为目标或者主题(Subject),依赖的对象称为观察者(Observer)

首先，实现一个观察者接口，一般来说该接口有一个update方法

/**
 *
 * @author Administrator
 * 观察者接口
 */
public interface Observer {
    
    void update(Observable o,Object arg);
}

接下来实现一个被观察者的抽象类

/**
 *
 * @author Administrator
 * 被观察者类
 */
public abstract class Observable {
    
    //使用一个list来保存该对象上所有绑定的事件监听器
    List<Observer> observers = new ArrayList<>();
    
    //注册事件监听器
    public void registerObserver(Observer observer)
    {
        this.observers.add(observer);
    }
    
    //删除指定事件监听器
    public void removeObserver(Observer observer)
    {
        this.observers.remove(observer);
    }
    
    //通知该主题上注册的所有观察者
    public void notifyObserver(Object value)
    {
        //遍历list
        for(Iterator<Observer> it = observers.iterator();it.hasNext();)
        {
            Observer o = it.next();
            //显式调用每个观察者的update方法
            o.update(this, value);
        }
    }
}

实现我们具体的主题（被观察者的实现类）

/**
 *
 * @author Administrator
 */
public class Product extends Observable{
    
    private String name;
    private double price;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
        //触发事件
        notifyObserver(name);
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
        //触发事件
        notifyObserver(price);
    }
    
    
}

实现两个观察者

/**
 *
 * @author Administrator
 */
public class PriceObserver implements Observer{

    @Override
    public void update(Observable o, Object arg) {
        if(arg instanceof Double)
        {
            double price = (Double)arg;
           System.out.println("观察者:"+o+",物品名称已经改变为:"+price);
        }
    }
    
    
}

/**
 *
 * @author Administrator
 */
public class NameObserver implements Observer{

    @Override
    public void update(Observable o, Object arg) {
        if(arg instanceof String)
        {
            //产品名称改变值在name中
            String name = (String)arg;
            System.out.println("观察者:"+o+",物品名称已经改变为:"+name);
        }
    }
}

测试类：

/**
 *
 * @author Administrator
 */
public class Test {
    
    public static void main(String[] args) {
        //创建一个被观察者对象
        Product p = new Product();
        
        //创建两个观察者对象
        NameObserver no = new NameObserver();
        PriceObserver po = new PriceObserver();
        
        //注册观察者对象
        p.registerObserver(po);
        p.registerObserver(no);
        
        p.setName("Iphone5");
        p.setPrice(4999);
    }
    
}

观察者模式包含四个角色：
被观察者的抽象基类：它通常会持有多个观察者对象的引用。Java提供了java.util.Observerable基类来代表被观察者的抽象基类。
观察者接口：该接口是所有观察者应该实现的接口。通常它包含一个抽象方法update();Java同样提供了Observer接口代表观察者接口
被观察的实现类:该类继承Observerable类

观察者的实现类：该类实现Observer接口的update方法