編程模式之觀察者模式(Observer)

觀察者模式由四個角色組成:抽象主題角色，抽象觀察者角色，具體主題角色，抽象觀察者角色，具體觀察者角色。

抽象主題角色(Subject)：把所有的觀察者角色的引用保存在一個集合中，可以有任意數量的觀察者。其提供一個介面，可以添加、刪除觀察者，並可以向登記過的觀察者發送通知。

具體主題角色(Observer)：實現了抽象主題角色提供的介面的一個具體類。

抽象觀察者角色(ConcreteSubject)：提供一個藉口，以接收主題角色發送的通知。

具體觀察者角色(ConcreteObserver)：實現了抽象觀察者角色提供的介面的一個具體類。

 類圖

JAVA代碼：

package com.observer;

import java.util.ArrayList;
import java.util.List;

/**
 * 抽象主題角色，被觀察
 * @author hyp
 *
 */
public interface Subject
{
    void addWatcher(Watcher watcher);
    void removeWatcher(Watcher watcher);
    void notify(String message);
}


/**
 * 抽象觀察者角色，觀察主題
 * @author hyp
 *
 */
public interface Watcher
{
    void update(String message);
}




/**
 * 具體主題角色
 * @author hyp
 *
 */
public class ConcreteSubject implements Subject
{
    private List<Watcher> watchers = new ArrayList<Watcher>();
    
    @Override
    public void addWatcher(Watcher watcher)
    {
        watchers.add(watcher);
    }

    @Override
    public void removeWatcher(Watcher watcher)
    {
        watchers.remove(watcher);
    }

    @Override
    public void notify(String message)
    {
        for(Watcher w:watchers)
        {
            w.update(message);
        }
    }
}


/**
 * 具體觀察者橘色
 * @author hyp
 *
 */
public class ConcreteWatcher implements Watcher
{

    @Override
    public void update(String message)
    {
        System.out.println(this.toString()+ ":" + message);
    }
}

/**
 * 測試觀察者模式
 * @author hyp
 *
 */
public class Test
{
    public static void main(String[] args)
    {
        Subject subject= new ConcreteSubject();
        Watcher watcher1 = new ConcreteWatcher();
        Watcher watcher2 = new ConcreteWatcher();
        Watcher watcher3 = new ConcreteWatcher();
        
        Subject.addWatcher(watcher1);//添加觀察者
        Subject.addWatcher(watcher2);
        Subject.addWatcher(watcher3);
        
        Subject.notify("Hello");//通知所有觀察者
        
        Subject.removeWatcher(watcher1);//移除一個觀察者
        
        Subject.notify("bye~");
        
    }
}