观察者模式

package JAVABasic;

import java.util.Vector;

/**
 * 
 * @author markGao
 * 
 */
public class ObserverMode {

    public static void main(String args[]) {
        ProductControl productControl = new ProductControl();
        Observer nameobs = new NameObserver();

        Observer priceobs = new PriceObserver();
        Product product = new Product();
        productControl.setProduct(product);
        productControl.register(nameobs, priceobs);
        product.setName("橘子");

        product.setPrice(1.22f);

    }

}

class ProductControl {
    private Product product;

    public void setProduct(Product product) {
        this.product = product;
    }

    public void register(Observer priceObsv, Observer nameObsv) {
        // 加入观察者
        product.addObserver(priceObsv);
        product.addObserver(nameObsv);

    }

    public void removeNameObserver(NameObserver nameObsv) {
        product.deleteObserver(nameObsv);
    }

    public void removePriceObserver(PriceObserver priceObsv) {
        product.deleteObserver(priceObsv);
    }
}

/**
 * 
 * Product类继承被观察者， 具有被观察者的能力。
 * 
 */
class Product extends Observable {
    private String name;
    private float price;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
        // 设置变化点
        setChanged();
        // 触发响应
        notifyObservers(name);
    }

    public float getPrice() {
        return price;
    }

    public void setPrice(float price) {
        this.price = price;
        // 设置变化点
        setChanged();
        // 触发响应
        notifyObservers(new Float(price));

    }
}

/**
 * 被观察者基础类
 * 
 * @author markGao
 * 
 */
class Observable {
    private boolean changed = false;
    private Vector<Observer> obs;

    // 创建被观察者时就创建一个它持有的观察者列表，注意，这个列表是需要同步的。
    public Observable() {
        obs = new Vector<Observer>();
    }

    public void setChanged() {
        changed = !changed;

    }

    /**
     * 添加观察者到观察者列表中去
     */
    public synchronized void addObserver(Observer o) {
        if (o == null)
            throw new NullPointerException();
        if (!obs.contains(o)) {
            obs.addElement(o);
        }
    }

    /**
     * 删除一个观察者
     */
    public synchronized void deleteObserver(Observer o) {
        obs.removeElement(o);
    }

    /**
     * 通知操作，即被观察者发生变化，通知对应的观察者进行事先设定的操作，不传参数的通知方法
     */
    public void notifyObservers() {
        notifyObservers(null);
    }

    /**
     * 与上面的那个通知方法不同的是，这个方法接受一个参数，这个参数一直传到观察者里，以供观察者使用
     */
    public void notifyObservers(Object arg) {

        Object[] arrLocal;

        synchronized (this) {
            if (!changed)
                return;
            arrLocal = obs.toArray();
            clearChanged();
        }

        for (int i = arrLocal.length - 1; i >= 0; i--)
            ((Observer) arrLocal[i]).update(this, arg);
    }

    private void clearChanged() {
        changed = false;

    }
}

interface Observer {
    /**
     * This method is called whenever the observed object is changed. An
     * application calls an <tt>Observable</tt> object's
     * <code>notifyObservers</code> method to have all the object's observers
     * notified of the change.
     * 
     * @param o
     *            the observable object.
     * @param arg
     *            an argument passed to the <code>notifyObservers</code> method.
     */
    void update(Observable o, Object arg);
}

class NameObserver implements Observer {
    private String name = "";

    public void update(Observable obj, Object arg) {
        if (arg instanceof String) {
            name = (String) arg;
            System.out.println("NameObserver:name changet to " + name);
        }
    }

}

class PriceObserver implements Observer {

    private float price = 0;

    public void update(Observable obj, Object arg) {
        if (arg instanceof Float) {
            price = ((Float) arg).floatValue();
            System.out.println("PriceObserver:price changet to" + price);
        }
    }

}