精华内容
下载资源
问答
  • Java观察者模式

    千次阅读 2014-03-24 23:59:01
    Java观察者模式定义对象间一对多的依赖关系,当一个对象(被观察者)的状态发生改变时,所有依赖于它的对象(观察者)都得到通知并自动更新。JDK中提供的观察者模式的实现是由java.util.Observer接口和java.util....

    Java观察者模式定义对象间一对多的依赖关系,当一个对象(被观察者)的状态发生改变时,所有依赖于它的对象(观察者)都得到通知并自动更新。JDK中提供的观察者模式的实现是由java.util.Observer接口和java.util.Observable类组成的,其中Observer代表观察者,而Observable代表被观察者。




    1、Observable类是由被观察者(可有一个或多个观察者)所继承,调用setChanged方法,是的hasChanged方法返回值为true,则再次调用notifyObservers方法会触发观察者的update方法来通知观察者该实例发生变化。


    2、Observer接口中只有一个为实现的update抽象方法,实现该接口的对象称为观察者,该对象要实现update方法。注册了该对象(观察者)的对象(被观察者)实例在调用notifyObservers方法之后,会自动调用观察者中的update方法。


    3、被观察者I114gBoxHeaterObservable.java,代表热水器,继承Obserable,其实现如下:

    /**
     * 
     */
    package com.i114gbox.sdk.designMode.observer;
    
    import java.util.Observable;
    
    /**
     * 热水器--被观察者
     * 
     * @author shenjichao@vivagame.cn
     * 
     */
    public class I114gBoxHeaterObservable extends Observable {
    
    	// 水温
    	private int temperature;
    
    	public int getTemperature() {
    		return temperature;
    	}
    
    	public void setTemperature(int temperature) {
    		this.temperature = temperature;
    	}
    
    	// 烧水
    	public void boilWater() {
    		for (int i = 10; i <= 100;) {// 初始水温为15度
    			temperature = i;
    			// 调用setChanged(),hasChanged()将返回true
    			this.setChanged();
    			// 当hasChanged()返回true时,监听被观察者的观察者将调用update()
    			this.notifyObservers();
    			i += 10;
    		}
    	}
    
    }
    

    4、在扮演观察者角色的同时,又扮演被观察者的角色,类名为I114gBoxDisplayObservable.java,代表显示器,继承Observable类,实现Observer接口,其实现如下:

    /**
     * 
     */
    package com.i114gbox.sdk.designMode.observer;
    
    import java.util.Observable;
    import java.util.Observer;
    import java.util.logging.Logger;
    
    /**
     * 显示器--观察者(用于观察热水器),被观察者(被报警器观察)
     * 
     * @author shenjichao@vivagame.cn
     * 
     */
    public class I114gBoxDisplayObservable extends Observable implements Observer {
    	private static Logger logger = Logger
    			.getLogger(I114gBoxDisplayObservable.class.getSimpleName());
    
    	private String status = I114gBoxWaterStatus.COLD.toString();
    
    	public String getStatus() {
    		return status;
    	}
    
    	public void setStatus(String status) {
    		this.status = status;
    	}
    
    	// 显示水温
    	private void displayTemperature(int temperature) {
    		// 当水被烧开时
    		if (temperature == 100) {
    			this.setStatus(I114gBoxWaterStatus.HOT.toString());
    			this.setChanged();
    			this.notifyObservers(temperature);
    		}
    
    		logger.info("水状态为:" + status + "|" + "现在水温为:" + temperature);
    	}
    
    	// 当被观察者状态发生改变时,调用该方法
    	@Override
    	public void update(Observable observable, Object data) {
    		this.displayTemperature(((I114gBoxHeaterObservable) observable)
    				.getTemperature());
    	}
    
    }
    

    5、观察者I114gBoxAlarmObserver.java,代表报警器,实现Observer接口,其实现如下:

    /**
     * 
     */
    package com.i114gbox.sdk.designMode.observer;
    
    import java.util.Observable;
    import java.util.Observer;
    import java.util.logging.Logger;
    
    /**
     * 报警器--观察者
     * 
     * @author shenjichao@vivagame.cn
     * 
     */
    public class I114gBoxAlarmObserver implements Observer {
    	private static Logger logger = Logger.getLogger(I114gBoxAlarmObserver.class
    			.getSimpleName());
    
    	// 当水烧开了调用该方法
    	@Override
    	public void update(Observable observable, Object data) {
    		this.makeAlarm((Integer) data);
    	}
    
    	// 报警
    	private void makeAlarm(int temperature) {
    		logger.info("滴滴滴……水烧开了!");
    	}
    
    }
    

    6、观察者模式测试类Test.java,其实现如下:

    /**
     * 
     */
    package com.i114gbox.sdk.designMode.observer;
    
    /**
     * 观察者模式测试类
     * 
     * @author shenjichao@vivagame.cn
     * 
     */
    public class Test {
    
    	public static void main(String[] args) {
    
    		I114gBoxHeaterObservable heater = new I114gBoxHeaterObservable();
    		I114gBoxDisplayObservable display = new I114gBoxDisplayObservable();
    		I114gBoxAlarmObserver alarm = new I114gBoxAlarmObserver();
    
    		// 加入观察者
    		// 显示器用来观察热水器
    		heater.addObserver(display);
    		// 报警器用来观察显示器
    		display.addObserver(alarm);
    
    		// 烧水
    		heater.boilWater();
    
    	}
    
    }
    

    7、运行测试类,结果如下:



    8、注意事项

       优点:

    支持松耦合和减少依赖性;

    观察者数目可变

       缺点:

    性能降低;

    内存泄露;

    测试调试困难

    展开全文
  • java观察者模式

    千次阅读 2018-09-04 10:53:37
    首先,弄明白两组概念:观察者(Observer)与被观察者(subject)、发布者(publicsher)与订阅者(subscriber)。这是相似的两组概念,讲的...观察者模式说白了,其实就是发布订阅模式,发布者发布信息,订阅者获...

    文章目录


    首先,弄明白两组概念:观察者(Observer)与被观察者(subject)、发布者(publicsher)与订阅者(subscriber)。这是相似的两组概念,讲的时候,要对应于各自所在的组,不要弄混了。

    对象之间定义了一对多的依赖,这样一来,当一个对象改变状态,依赖它的对象会收到通知并自动更新。(这和前端vue的思想相同)
    观察者模式说白了,其实就是发布订阅模式,发布者发布信息,订阅者获取信息,订阅了就能收到信息,没订阅就收不到信息。

    思路

    • 抽象出观察者接口
    • 抽象出被观察者接口
    • 观察者类实现观察者接口
    • 被观察者类实现被观察者接口(被观察者持有观察者的一个队列)

    具体实现

    实现时,可以不一步到位,在遇到问题的时候,你也许就知道该怎么做了

    package com.wanmei.meishu.ms;
    
    import java.util.ArrayList;
    import java.util.List;
    
    //观察者接口
    interface Observable{
    	//观察
    	void addSub(ISubject sub);
    	//取消观察
    	void removeSub(ISubject sub,String msg);
    	//读取消息
    	void watch(String msg);
    	//获取观察者名称
    	String getName();
    }
    //观察者实例
    class Observer implements Observable {
    	private String name;
    	public Observer(String name) {
    		this.name = name;
    	}
    	@Override
    	public void addSub(ISubject sub){
    		sub.addObserver(this);
    		System.out.println("Observer:用户【"+this.name+"】 订阅了消息");
    	}
    	@Override
    	public void removeSub(ISubject sub,String msg){
    		sub.removeObserver(this);
    		System.out.println("Observer:用户【"+this.name+"】 取消了订阅消息," + (msg == null ? "" : ("并说:" + msg)));
    	}
    	@Override
    	public void watch(String msg) {
    		System.out.println("Observer:用户【"+this.name+"】读取到的订阅消息是:" + msg);
    	}
    	
    	public String getName() {
    		return name;
    	}
    }
    
    //被观察者接口
    interface ISubject{
    	//给观察者们发送消息
    	void sendMsg(String msg);
    	//添加一个观察者
    	void addObserver(Observable user);
    	//取消一个观察者
    	void removeObserver(Observable user);
    }
    
    //被观察者实现方式
    class SubjectImpl implements ISubject{
    	
    	//持有观察者队列
    	private List<Observable> observerList;
    
    	//添加一个观察者
    	public synchronized void addObserver(Observable user){
    		if(observerList == null){
    			observerList = new ArrayList<Observable>();
    		}
    		observerList.add(user);
    		String str = "";
    		for (Observable observable : observerList) {
    			str+= observable.getName()+"、";
    		}
    		System.out.println("ISubject:目前已有用户:" + str.substring(0, str.length()-1));
    	}
    	//取消一个观察者
    	public void removeObserver(Observable user){
    		observerList.remove(user);
    		if(!observerList.isEmpty()){
    			String str = "";
    			for (Observable observable : observerList) {
    				str+= observable.getName()+"、";
    			}
    			System.out.println("ISubject:目前剩余用户:" + str.substring(0, str.length()- 1));
    		}
    	}
    	@Override
    	public void sendMsg(String msg) {
    		if(!observerList.isEmpty()){
    			System.out.println("ISubject:发送消息:" + msg);
    			for (Observable observable : observerList) {
    				observable.watch(msg);
    			}
    		}
    	}
    	
    }
    
    public class ObserverTest {
    
    	public static void main(String[] args) {
    		ISubject sub = new SubjectImpl();
    		//第一个观察者
    		Observable u1 = new Observer("吴文俊");
    		u1.addSub(sub);
    		Observable u2 = new Observer("吴华云");
    		u2.addSub(sub);
    		Observable u3 = new Observer("李爪哇");
    		u3.addSub(sub);
    		sub.sendMsg("PHP是世界上最好的语言!");
    		u3.removeSub(sub,"去死吧,PHP");
    		sub.sendMsg("PHP是世界上最好的语言!");
    		
    		
    	}
    }
    
    

    运行结果:

    ISubject:目前已有用户:吴文俊
    Observer:用户【吴文俊】 订阅了消息
    ISubject:目前已有用户:吴文俊、吴华云
    Observer:用户【吴华云】 订阅了消息
    ISubject:目前已有用户:吴文俊、吴华云、李爪哇
    Observer:用户【李爪哇】 订阅了消息
    ISubject:发送消息:PHP是世界上最好的语言!
    Observer:用户【吴文俊】读取到的订阅消息是:PHP是世界上最好的语言!
    Observer:用户【吴华云】读取到的订阅消息是:PHP是世界上最好的语言!
    Observer:用户【李爪哇】读取到的订阅消息是:PHP是世界上最好的语言!
    ISubject:目前剩余用户:吴文俊、吴华云
    Observer:用户【李爪哇】 取消了订阅消息并说:去死吧,PHP
    ISubject:发送消息:PHP是世界上最好的语言!
    Observer:用户【吴文俊】读取到的订阅消息是:PHP是世界上最好的语言!
    Observer:用户【吴华云】读取到的订阅消息是:PHP是世界上最好的语言!
    
    
    展开全文
  • Java 观察者模式

    千次阅读 2008-10-16 11:11:00
    网上商店中的商品在名称、价格发生变化时,必须自动通知会员,Java的API为我们提供了Observer接口和Observable类来实现所谓观察者模式。 Observable(可观察者)类允许在自身发生改变时,通知其它对象(实现接口...
     
    

    网上商店中的商品在名称、价格发生变化时,必须自动通知会员,Java的API为我们提供了Observer接口和Observable类来实现所谓观察者模式。
      Observable(可观察者)类允许在自身发生改变时,通知其它对象(实现接口Observer,观察者)。
      下面是一个可观察者(产品类):
    import java.util.*;
    public 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));

       }

       以下可以是数据库更新 插入命令.
       public void saveToDb(){
       System.out.println("saveToDb");
        }

    }

    下面是两个观察者:
    import java.util.*;
    public class NameObserver implements Observer{

       private String name=null;
       public void update(Observable obj,Object arg){
         if (arg instanceof String){
          name=(String)arg;
          产品名称改变值在name中
          System.out.println("NameObserver :name changet to "+name);

         }

          }
       }

    import java.util.*;
    public 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);

         }


       }

    }
    下面是测试类:
    public class Test {

       public static void main(String args[]){
        Product product=new Product();
        NameObserver nameobs=new NameObserver();
        PriceObserver priceobs=new PriceObserver();

        加入观察者
        product.addObserver(nameobs);
        product.addObserver(priceobs);

        product.setName("applet");
        product.setPrice(9.22f);

       }
    }
    运行结果:
    C:/java>java  Test
    NameObserver :name changet to applet
    PriceObserver :price changet to 9.22

    展开全文
  • java观察者模式

    千次阅读 2007-10-26 22:21:00
    引子还记得警匪片上,匪徒们是怎么配合实施犯罪的吗?一个团伙在进行盗窃的时候,总 有一两个人在门口把风——如果有什么风吹草动,则会...呵呵,上面提到的放风者、偷窃者之间的关系就是观察者模式在现实中的活生生的
    引子
    
    还记得警匪片上,匪徒们是怎么配合实施犯罪的吗?一个团伙在进行盗窃的时候,总    有一两个人在门口把风——如果有什么风吹草动,则会立即通知里面的同伙紧急撤退。也许放风的人并不一定认识里面的每一个同伙;而在里面也许有新来的小弟不认识这个放风的。但是这没什么,这个影响不了他们之间的通讯,因为他们之间有早已商定好的暗号。
    呵呵,上面提到的放风者、偷窃者之间的关系就是观察者模式在现实中的活生生的例子。

    二、定义与结构

    观察者(Observer)模式又名发布-订阅(Publish/Subscribe)模式。GOF给观察者模式如下定义:定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。

    在这里先讲一下面向对象设计的一个重要原则——单一职责原则。因此系统的每个对象应该将重点放在问题域中的离散抽象上。因此理想的情况下,一个对象只做一件事情。这样在开发中也就带来了诸多的好处:提供了重用性和维护性,也是进行重构的良好的基础。

    因此几乎所有的设计模式都是基于这个基本的设计原则来的。观察者模式的起源我觉得应该是在GUI和业务数据的处理上,因为现在绝大多数讲解观察者模式的例子都是这一题材。但是观察者模式的应用决不仅限于此一方面。

    下面我们就来看看观察者模式的组成部分。

    1)        抽象目标角色(Subject):目标角色知道它的观察者,可以有任意多个观察者观察同一个目标。并且提供注册和删除观察者对象的接口。目标角色往往由抽象类或者接口来实现。
    2)        抽象观察者角色(Observer):为那些在目标发生改变时需要获得通知的对象定义一个更新接口。抽象观察者角色主要由抽象类或者接口来实现。
    3)        具体目标角色(Concrete Subject):将有关状态存入各个Concrete Observer对象。当它的状态发生改变时, 向它的各个观察者发出通知。
    4)        具体观察者角色(Concrete Observer):存储有关状态,这些状态应与目标的状态保持一致。实现Observer的更新接口以使自身状态与目标的状态保持一致。在本角色内也可以维护一个指向Concrete Subject对象的引用。
    放上观察者模式的类图,这样能将关系清晰的表达出来。

     

           可以看得出来,在Subject这个抽象类中,提供了上面提到的功能,而且存在一个通知方法:notify。还可以看出来Subject和ConcreteSubject之间可以说是使用了模板模式(这个模式真是简单普遍到一不小心就用到了)。

           这样当具体目标角色的状态发生改变,按照约定则会去调用通知方法,在这个方法中则会根据目标角色中注册的观察者名单来逐个调用相应的update方法来调整观察者的状态。这样观察者模式就走完了一个流程。

           在下面的例子中会更深刻的体验到这个流程的。

    三、举例

    观察者模式是我在《JUnit源代码分析》中遗留的一个模式,因此这里将采用JUnit来作为例子。

    JUnit为用户提供了三种不同的测试结果显示界面,以后还可能会有其它方式的现实界面……。怎么才能将测试的业务逻辑和显示结果的界面很好的分离开?不用问,就是观察者模式!

    下面我们来看看JUnit中观察者模式的使用代码:

    //下面是我们的抽象观察者角色,JUnit是采用接口来实现的,这也是一般采用的方式。

    //可以看到这里面定义了四个不同的update方法,对应四种不同的状态变化

    public interface TestListener {

           /**

           * An error occurred.

           */

           public void addError(Test test, Throwable t);

           /**

           * A failure occurred.

           */

          public void addFailure(Test test, AssertionFailedError t); 

           /**

            * A test ended.

            */

          public void endTest(Test test);

           /**

            * A test started.

            */

           public void startTest(Test test);

    }

    //具体观察者角色,我们采用最简单的TextUI下的情况来说明(AWT,Swing对于整天做Web应用的人来说,已经很陌生了)

    public class ResultPrinter implements TestListener {

           //省略好多啊,主要是显示代码

    ……

           //下面就是实现接口TestListener的四个方法

           //填充方法的行为很简单的说

           /**

            * @see junit.framework.TestListener#addError(Test, Throwable)

            */

           public void addError(Test test, Throwable t) {

                  getWriter().print("E");

           }

           /**

            * @see junit.framework.TestListener#addFailure(Test, AssertionFailedError)

            */

           public void addFailure(Test test, AssertionFailedError t) {

                  getWriter().print("F");

           }

           /**

            * @see junit.framework.TestListener#endTest(Test)

            */

           public void endTest(Test test) {

           }

           /**

            * @see junit.framework.TestListener#startTest(Test)

            */

           public void startTest(Test test) {

                  getWriter().print(".");

                  if (fColumn++ >= 40) {

                         getWriter().println();

                         fColumn= 0;

                  }

           }

    }

    来看下我们的目标角色,随便说下,由于JUnit功能的简单,只有一个目标——TestResult,因此JUnit只有一个具体目标角色。

    //好长的代码,好像没有重点。去掉了大部分与主题无关的信息

    //下面只列出了当Failures发生时是怎么来通知观察者的

    public class TestResult extends Object {

           //这个是用来存放测试Failures的集合

    protected Vector fFailures;

    //这个就是用来存放注册进来的观察者的集合

           protected Vector fListeners;

           public TestResult() {

                  fFailures= new Vector();

                  fListeners= new Vector();

           }

           /**

            * Adds a failure to the list of failures. The passed in exception

            * caused the failure.

            */

           public synchronized void addFailure(Test test, AssertionFailedError t) {

                  fFailures.addElement(new TestFailure(test, t));

                  //下面就是通知各个观察者的addFailure方法

                  for (Enumeration e= cloneListeners().elements(); e.hasMoreElements(); ) {

                         ((TestListener)e.nextElement()).addFailure(test, t);

                  }

           }

           /**

            * 注册一个观察者

            */

           public synchronized void addListener(TestListener listener) {

                  fListeners.addElement(listener);

           }

           /**

            * 删除一个观察者

            */

           public synchronized void removeListener(TestListener listener) {

                  fListeners.removeElement(listener);

           }

           /**

            * 返回一个观察者集合的拷贝,当然是为了防止对观察者集合的非法方式操作了

         * 可以看到所有使用观察者集合的地方都通过它

            */

           private synchronized Vector cloneListeners() {

                  return (Vector)fListeners.clone();

           }

           ……

    }

    嗯,观察者模式组成所需要的角色在这里已经全了。不过好像还是缺点什么……。呵呵,对!就是它们之间还没有真正的建立联系。在JUnit中是通过TestRunner来作的,而你在具体的系统中可以灵活掌握。

    看一下TestRunner中的代码:

    public class TestRunner extends BaseTestRunner {

           private ResultPrinter fPrinter;

    public TestResult doRun(Test suite, boolean wait) {

    //就是在这里注册的

                  result.addListener(fPrinter);

    ……

    四、使用情况

    GOF给出了以下使用观察者模式的情况:
    1)        当一个抽象模型有两个方面, 其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。
    2)        当对一个对象的改变需要同时改变其它对象, 而不知道具体有多少对象有待改变。
    3)        当一个对象必须通知其它对象,而它又不能假定其它对象是谁。换言之, 你不希望这些对象是紧密耦合的。
    其实观察者模式同前面讲过的桥梁、策略有着共同的使用环境:将变化独立封装起来,以达到最大的重用和解耦。观察者与后两者不同的地方在于,观察者模式中的目标和观察者的变化不是独立的,而是有着某些联系。

    五、我推你拉

    观 察者模式在关于目标角色、观察者角色通信的具体实现中,有两个版本。一种情况便是目标角色在发生变化后,仅仅告诉观察者角色“我变化了”;观察者角色如果 想要知道具体的变化细节,则就要自己从目标角色的接口中得到。这种模式被很形象的称为:拉模式——就是说变化的信息是观察者角色主动从目标角色中“拉”出 来的。

    还有一种方法,那就是我目标角色“服务一条龙”,通知你发生变化的同时,通过一个参数将变化的细节传递到观察者角色中去。这就是“推模式”——管你要不要,先给你啦。

    这两种模式的使用,取决于系统设计时的需要。如果目标角色比较复杂,并且观察者角色进行更新时必须得到一些具体变化的信息,则“推模式”比较合适。如果目标角色比较简单,则“拉模式”就很合适啦。


     


     

    注:以上内容来自网络,本人不承担连带责任...
    本帖转自:http://blog.csdn.net/hangke/archive/2007/10/10/1818471.aspx
    展开全文
  • Java观察者模式(Observer)

    千次阅读 多人点赞 2019-02-16 23:57:11
      观察者模式java GOF23种设计模式中的一种。在最近介绍的Redis和ActiveMQ中都涉及到了观察者模式,所以我们在本文详细介绍下此模式: 观察者模式   观察者模式又称为发布/订阅(Publish/Subscribe)模式,在对象...
  • Java 观察者模式的浅析 简单地说,观察者模式定义了一个一对多的依赖关系,让一个或多个观察者对象监察一个主题对象。这样一个主题对象在状态上的变化能够通知所有的依赖于此对象的那些观察者对象,使这些观察者...
  • 注意:观察者模式和发布订阅模式是有区别的,区别在于观察者模式是由目标进行调度,而发布订阅模式是由独立的调度中心进行调度,可以说发布订阅模式是观察者模式进一步解耦,在实际中被大量运用的一种模式。...
  • 用Spring提高java观察者模式灵活性

    千次阅读 2014-07-28 17:51:02
    在上篇博客 用java观察者模式解耦经典三层架构 中,
  • Java观察者模式例子

    千次阅读 2013-07-26 16:51:13
    * 气温预报(观察者模式) * @author Administrator *被观察者接口即subject目标接口气温 */ public interface Temperature{ //增加观察者 public void addObs(Observer o); //删除观察者 public voi
  • java观察者模式不一样的使用

    千次阅读 2017-03-25 00:35:24
    java8出现之前,我们使用JDK中的观察者模式,只能是使用被观察者类继承自Observable类,观察者类实现Observer接口来实现。对这一部分不熟悉的同学,请参考 ... 这样子使用是没有什么问题的,但是并不完美。...
  • 一、观察者模式所涉及的角色有:  ● 抽象主题(Subject)角色:抽象主题角色把所有对观察者对象的引用保存在一个聚集(比如ArrayList对象)里,每个主题都可以有任何数量的观察者。抽象主题提供一个接口,可以增加...
  • java观察者模式举例

    千次阅读 2013-11-13 22:24:17
    观察者模式(有时又被称为发布-订阅Subscribe>模式、模型-视图View>模式、源-收听者Listener>模式或从属者模式)是软件设计模式的一种。在此种模式中,一个目标物件管理所有相依于它的观察者物件,并且在它本身的...
  • java 观察者模式利与弊分析

    千次阅读 2017-07-04 14:31:34
    观察者模式是比较常用的一种设计模式,观察者模式定义了一个一对多的依赖关系,让一个或多个观察者对象监听一个主题对象。当被观察者状态发生改变时通知相应的观察者,使得这些观察者对象能够自动更新。但当我们使用...
  • 关于Java观察者模式的一点思考

    千次阅读 2018-08-22 10:52:49
    Java里面有个观察者模式,网上的相关介绍有很多,所以在这儿那种很官方很书面的话我就不贴过来了。尽量用说人话的方式表达一些自己对这个设计模式的思考。 顾名思义“观察者”模式应该是来实现“观察”或者“监听”...
  • 观察者模式 实际案例 定义 测试 实现方式 UML &amp; Code UML Code 系列导航 观察者模式 当对象间存在一对多关系时,则使用观察者模式(Observer Pattern)。 比如,当一个对象被修改时,则会自动...
  • java观察者模式介绍

    千次阅读 2014-03-17 11:42:59
     Observer模式定义对象间的一对多的依赖关系,当一个对象(被观察者)的状态发生改变时, 所有依赖于它的对象(观察者)都得到通知并被自动更新。JDK里提供的observer设计模式的实现由java.util.Observable类和 java....
  • Java的设计模式很多,观察者模式被称为是模式中的皇后,而且Java jdk也对它做了实现,可见该设计模式的重要位置。在图形化设计的软件中,为了实现视图和事件处理的分离,大多都采用了Observer模式,比如Java的Swing...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 119,649
精华内容 47,859
关键字:

java观察者模式

java 订阅