觀察者模式

觀察者模式涉及到2個對象：觀察者和被觀察者

但是並不是觀察者時時觀察着被觀察者，而是被觀察者改變時通知觀察它的觀察者。

所以更傾向於叫它：訂閱播報模式。
訂閱後當有更新的時候主動通知訂閱者

/**  
 * 觀察者(訂閱者)接口  
 * @author Administrator  
 *  
 */    
public interface Observer {    

    public void notify();    
}    


public class Student implements Obser{

    @Override
    public void update() {
        // TODO Auto-generated method stub
        System.out.println("我知道書單更新了");

    }

}

//被觀察者
public interface Oberverle {
    public void addObser(Obser o);
    public void removeObser(Obser o);
    public void notify();


}


public class Book implements Oberverle{
    List<Obser> list;
    public Book() {
        // TODO Auto-generated constructor stub
        list=new ArrayList<>();
    }
    @Override
    public void addObser(Obser o) {
        // TODO Auto-generated method stub
        list.add(o);

    }
    @Override
    public void removeObser(Obser o) {
        // TODO Auto-generated method stub
        list.remove(o);

    }
    @Override
    public void update() {
        // TODO Auto-generated method stub
        for (Obser obser : list) {
            obser.update();
        }

    }
}

//測試
public class Test {
    public static void main(String[] args) {
        Student s=new Student();
        Book b=new Book();
        b.addObser(s);
        //b.removeObser(s);
        b.update();
    }

}

以下百度百科

//觀察者，需要用到觀察者模式的類需實現此接口
public interface Observer{
    void update(Object...objs);
}

//被觀察者（一個抽象類，方便擴展）
public abstract class Observable{

    public final ArrayList<Class<?>> obserList = new ArrayList<Class<?>>();

    /**AttachObserver（通過實例註冊觀察者）
    *<b>Notice:</b>obcan'tbenull,oritwillthrowNullPointerException
    **/
    public<T> void registerObserver(T ob){
        if(ob==null) throw new NullPointerException();
        this.registerObserver(ob.getClass());
    }

    /**
    *AttachObserver（通過Class註冊觀察者）
    *@paramcls
    */
    public void registerObserver(Class<?> cls){
        if(cls==null) throw new NullPointerException();
        synchronized(obserList){
            if(!obserList.contains(cls)){
                obserList.add(cls);
            }
        }
    }

    /**UnattachObserver（註銷觀察者）
    *<b>Notice:</b>
    *<b>ItreverseswithattachObserver()method</b>
    **/
    public<T>void unRegisterObserver(Tob){
        if(ob==null) throw new NullPointerException();
        this.unRegisterObserver(ob.getClass());
    }

    /**UnattachObserver（註銷觀察者，有時候在未獲取到實例使用）
    *<b>Notice:</b>
    *<b>ItreverseswithattachObserver()method</b>
    **/
    public void unRegisterObserver(Class<?>cls){
        if(cls==null) throw new NullPointerException();
        synchronized(obserList){
            Iterator<Class<?>>iterator=obserList.iterator();
            while(iterator.hasNext()){
                if(iterator.next().getName().equals(cls.getName())){
                    iterator.remove();
                    break;
                }
            }
        }
    }

    /**detachallobservers*/
    public void unRegisterAll(){
        synchronized(obserList){
            obserList.clear();
        }
    }

    /**Ruturnthesizeofobservers*/
    public int countObservers(){
        synchronized(obserList){
            returnobserList.size();
        }
    }

    /**
    *notify all observer（通知所有觀察者，在子類中實現）
    *@paramobjs
    */
    public abstract void notifyObservers(Object... objs);

    /**
    *notify one certain observer（通知某一個確定的觀察者）
    *@paramcls
    *@paramobjs
    */
    public abstract void notifyObserver(Class<?> cls, Object... objs);

    /**
    *notifyonecertainobserver
    *@paramcls
    *@paramobjs
    */
    public abstract<T> void notifyObserver(T t, Object... objs);
}

//目標被觀察者
public class ConcreteObservable extends Observable{

    private static ConcreteObservableinstance = null;
    private ConcreteObservable(){};
    public static synchronized ConcreteObservablegetInstance(){
        if(instance == null){
            instance=newConcreteObservable();
        }
        returninstance;
    }

    @Override
    public <T> void notifyObserver(T t, Object... objs){
        if(t == null) throw new NullPointerException();
        this.notifyObserver(t.getClass(), objs);
    }

    @Override
    public void notifyObservers(Object... objs){
        for(Class<?>cls : obserList){
            this.notifyObserver(cls, objs);
        }
    }


    //通過java反射機制實現調用
    @Override
    public void notifyObserver(Class<?>cls, Object...objs){
        if(cls == null) throw new NullPointerException();
        Method[] methods = cls.getDeclaredMethods();
        for(Method method : methods){
            if(method.getName().equals("update")){
                try{
                    method.invoke(cls,objs);
                    break;
                }catch(IllegalArgumentException e){
                    e.printStackTrace();
                }catch(IllegalAccessException e){
                    e.printStackTrace();
                }catch(InvocationTargetException e){
                    e.printStackTrace();
                }
            }
        }
    }
}

//使用(實現Observer接口）
public class Text extends Activity implements Observer{
    publicvoidonCreate(...){
        ConcreteObservable.getInstance().registerObserver(Text.class);
        ....
    }

    //實現接口處理
    publicvoidupdate(Object...objs){
        //做操作，比如更新數據，更新UI等
    }
}

重點內容