public class Watched
{
Watcher watcherList;
public synchronized void addWatcher(Watcher w)
{
if (w == null)
{
return;
}
watcherList =WatcherMultiCaster.add(watcherList,w);
}
public synchronized void removeWatcher(Watcher s) {
if (s == null) {
return;
}
watcherList = WatcherMultiCaster.remove(watcherList, s);
}
public void processAction(String msg){
Watcher w = watcherList;
if(w!=null){
w.action(msg);
}
}
}
//---------------------------------------------------------------------------------------------------------
public interface Watcher //观察者接口
{
public void action(String msg);
}
//---------------------------------------------------------------------------------------------------------
public class WatcherMultiCaster implements Watcher //铸造器
{
protected final Object a,b;
protected WatcherMultiCaster(Object a,Object b){
this.a = a;
this.b = b;
}
public static Watcher add(Watcher a,Watcher b){
return (Watcher) addInternal(a,b);
}
public static Watcher remove(Watcher w,Watcher oldw){
return (Watcher)removeInternal(w,oldw);
}
protected static Object addInternal(Object a,Object b){
if (a == null) return b;
if (b == null) return a;
return new WatcherMultiCaster(a, b);
}
protected static Object removeInternal(Object w, Object oldw)
{
if (w == oldw || w == null) {
return null;
} else if (w instanceof WatcherMultiCaster) {
return ((WatcherMultiCaster)w).remove(oldw);
} else {
return w;
}
}
private Object remove(Object oldw)
{
if (oldw == a) return b;
if (oldw == b) return a;
Object a2 = removeInternal(a, oldw);
Object b2 = removeInternal(b, oldw);
if (a2 == a && b2 == b) {
return this;
}
return addInternal(a2, b2);
}
@Override
public void action(String msg)
{
((Watcher)a).action(msg);
((Watcher)b).action(msg);
}
}
//---------------------------------------------------------------------------------------------------------
public class WatcherA implements Watcher
{
@Override
public void action(String msg)
{
System.out.println("WatcherA recived:"+msg);
}
}
public class WatcherB implements Watcher
{
@Override
public void action(String msg)
{
System.out.println("WatcherB recived: "+msg);
}
}
public class WatcherC implements Watcher
{
@Override
public void action(String msg)
{
System.out.println("WatcherC recived:"+msg);
}
}
//---------------------------------------------------------------------------------------------------------
public class ObserverTest
{
/**
* @param args
*/
public static void main(String[] args)
{
Watched watched = new Watched();
WatcherA wa = new WatcherA();
WatcherB wb = new WatcherB();
WatcherC wc = new WatcherC();
watched.addWatcher(wa);
watched.addWatcher(wb);
watched.addWatcher(wc);
watched.processAction("Stand up!");
watched.removeWatcher(wb);
watched.processAction("Sit down");
watched.addWatcher(new WatcherC());
watched.processAction("Sing!");
}
}
分享到:
相关推荐
python 实现 观察者模式3(双向解耦 抽象观察者,抽象通知者) python 实现 观察者模式4(委托) python 实现 简单工厂模式 python 实现 命令模式 python 实现 模板方法模式 python 实现 桥接模式 python 实现 适配器...
java实验策略模式、观察者模式和组合模式.docx
java实验策略模式、观察者模式和组合模式.doc
java实验:策略模式、观察者模式和组合模式
设计模式的分类,Java代码中使用观察者模式的案例以及文档
java实验:策略模式、观察者模式和组合模式.pdf
java实验策略规划模式、观察者模式和组合模式.pdf
java实验策略规划模式、观察者模式和组合模式.docx
java实验策略模式观察者模式和组合模式.pdf
java实验策略模式观察者模式和组合模式.doc
java实验策略模式观察者模式和组合模式.docx
基于观察者模式和单例模式的java聊天室 面向对象设计,抽象,封装,代理,组合和继承 适合理解java面向对象,socket编程,观察者模式和单例模式
抽象工厂模式、建造模式、工厂方法模式、原型模式、单例模式、外观模式、适配器模式、桥接模式、组合模式、装饰模式、享元模式、代理模式、命令模式、解释器模式、访问者模式、迭代子模式、中介者模式、备忘录模式、...
包含创建型模式,共五种:工厂方法模式、抽象...行为型模式,共十一种:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式的demo实现
3、观察者模式lua实现 4、状态模式lua实现 5、迭代器模式lua实现 6、备忘录模式lua实现 7、命令模式lua实现 8、职责链模式lua实现 9、解释器模式lua实现 10、中介者模式lua实现 11、访问者模式lua实现
里面包括组合模式、外观模式、代理模式、观察者模式、策略模式等设计模式
行为型模式,共十一种:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 其实还有两类:并发型模式和线程池模式。
33.2.1 中介者模式实现工资计算 33.2.2 门面模式实现工资计算 33.2.3 最佳实践 33.3 包装模式群PK 33.3.1 代理模式 33.3.2 装饰模式 33.3.3 适配器模式 33.3.4 桥梁模式 33.3.5 最佳实践 第四部分 完美世界—混编...
设计模式实例,java语言开发。 包括:工厂模式,观察者模式,装饰模式和桥梁模式。