Java设计模式--观察者模式到监听器
作者:互联网
观察者模式是对象的行为模式。又叫做发布-订阅模式、模型-视图模式、源-监听器模式。
抽象主题角色:主题角色将所有对观察者对象的引用到保存在一个集合里,每个主题都可以拥有任意数量的观察者。抽象主题提供一个接口,可以增加或者删除观察者对象。主题角色又叫被观察者。
具体主题角色:将有关状态存入具体观察者对象,在具体主题的内部状态改变时,给所有登记过的观察者发出通知。具体主题角色是抽象主题的一个具体子类实现。
抽象观察者角色:为所有的具体观察者定义一个接口,在得到主题通知的时候更新自己。
具体观察者角色:抽象观察者的具体子类实现。
代码
抽象主题
package com.demo.exercise.observer; /** * 抽象主题 */ public interface Subject { void add(Observer observer); void del(Observer observer); void notifyObservers(); }
抽象观察者
package com.demo.exercise.observer; /** * 抽象观察者 */ public interface Observer { void update(); }
具体观察者
package com.demo.exercise.observer; /** * 具体观察者 */ public class ConcreteObserver implements Observer { @Override public void update() { System.out.println(this + ":接收到通知了..."); } }
具体主题
package com.demo.exercise.observer; import java.util.Iterator; import java.util.Vector; /** * 具体主题 */ public class ConcreteSubject implements Subject { private Vector<Observer> observers = new Vector<>(); @Override public void add(Observer observer) { observers.add(observer); } @Override public void del(Observer observer) { observers.remove(observer); } @Override public void notifyObservers() { System.out.println("通知所有观察者..."); Iterator<Observer> iterator = observers.iterator(); while (iterator.hasNext()){ iterator.next().update(); } } }
运行
public static void main(String[] args) { Observer a = new ConcreteObserver(); Observer b = new ConcreteObserver(); Subject subject = new ConcreteSubject(); subject.add(a); subject.add(b); subject.notifyObservers(); }
输出
优化方案
上面的【抽象主题角色】,其中管理集合的方法,都是由子类来实现的,而实际情况则是这些管理集合的方法是所有实现子类共用的,所以可以把这些转移到抽象主题中去。
抽象主题(这里还是用的interface,你也可以用abstract class)
package com.demo.exercise.observer; import java.util.Iterator; import java.util.Vector; /** * 抽象主题 */ public interface Subject { Vector<Observer> observers = new Vector<>(); default void add(Observer observer){ observers.add(observer); } default void del(Observer observer){ observers.remove(observer); } default void notifyObservers(){ System.out.println("通知所有观察者..."); Iterator<Observer> iterator = observers.iterator(); while (iterator.hasNext()){ iterator.next().update(); } } /** * 子类需要自定义的方法 * @param status */ void change(String status); }
具体子类
package com.demo.exercise.observer; /** * 具体主题 */ public class ConcreteSubject implements Subject { private String status; /** * 主题状态改变,调用通知方法 * @param status */ public void change(String status){ System.out.println(status); this.status = status; this.notifyObservers(); } }
运行
public static void main(String[] args) { Observer a = new ConcreteObserver(); Observer b = new ConcreteObserver(); Subject subject = new ConcreteSubject(); subject.add(a); subject.add(b); subject.change("主题状态改变"); }
输出
引申
那么这种设计模式用来解决什么问题呢?类似于下面这种代码,大家初学Java的时候肯定用过,点击按钮事件,只要点击按钮,就会自动执行相关方法。
JButton button = new JButton(); button.addActionListener((event) -> { // TODO });
其中的原理也是观察者模式。下面我就来简单模拟一下
抽象主题
package com.demo.exercise.observer; import java.util.Iterator; import java.util.Vector; /** * 抽象主题 */ public abstract class Button { private Vector<ActionListener> observers = new Vector<>(); void addActionListener(ActionListener observer){ observers.add(observer); } void removeActionListener(ActionListener observer){ observers.remove(observer); } void notifyObservers(){ Iterator<ActionListener> iterator = observers.iterator(); while (iterator.hasNext()){ iterator.next().actionPerformed(); } } }
抽象观察者
package com.demo.exercise.observer; /** * 抽象观察者 */ public interface ActionListener { void actionPerformed(); }
具体主题
package com.demo.exercise.observer; /** * 具体主题 */ public class JButton extends Button { /** * 点击事件 */ public void click(){ System.out.println("【假装产生了点击事件】"); this.notifyObservers(); } }
运行
public static void main(String[] args) { JButton button = new JButton(); button.addActionListener(() -> { System.out.println("点击事件处理..."); }); button.addActionListener(() -> { System.out.println("另外一个点击事件处理..."); }); button.click(); }
输出
Java对观察者模式的支持
一个是被观察者:java.util.Observable
一个是观察者:java.util.Observer
Observer里面只有一个update方法。
public 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); }
当被观察者的状态发生改变,就会调用这一方法。
public void notifyObservers(Object arg) { /* * a temporary array buffer, used as a snapshot of the state of * current Observers. */ Object[] arrLocal; synchronized (this) { /* We don't want the Observer doing callbacks into * arbitrary code while holding its own Monitor. * The code where we extract each Observable from * the Vector and store the state of the Observer * needs synchronization, but notifying observers * does not (should not). The worst result of any * potential race-condition here is that: * 1) a newly-added Observer will miss a * notification in progress * 2) a recently unregistered Observer will be * wrongly notified when it doesn't care */ if (!changed) return; arrLocal = obs.toArray(); clearChanged(); } for (int i = arrLocal.length-1; i>=0; i--) ((Observer)arrLocal[i]).update(this, arg); }
用法呢,我再给你示范一下。
最简单的,仅仅需要自己实现一个观察者
package com.demo.exercise.observer; import java.util.Observable; import java.util.Observer; /** * 具体被观察者 */ public class JJButton extends Observable { public void change(){ // changed 置为true,表示状态改变,才会通知所有观察者,与之对应的是clearChanged this.setChanged(); // 通知所有观察者 this.notifyObservers(); } public void addListener(Observer o){ this.addObserver(o); } }
运行
public static void main(String[] args) { JJButton button = new JJButton(); button.addListener((o, arg) -> { System.out.println("点点点!!!"); }); button.change(); }
输出
为了好理解,对于事件监听一类的:事件发起者是被观察者,事件处理则是观察者,肯定是被观察者去通知观察者。
标签:Java,Observer,observer,void,观察者,observers,监听器,设计模式,public 来源: https://www.cnblogs.com/LUA123/p/11412468.html