精华内容
下载资源
问答
  • 使用观察者(Observer)实现对象监听

    千次阅读 2004-08-19 15:50:00
    使用观察者(Observer)实现对象监听 Bromon原创 请尊重版权 有非常多时候,我们希望自己的程序能够监视数据变化,然后做出响应,这种情况非常多,比如探测数据库中数据变化、检测用户状态变化等等。...

    使用观察者(Observer)实现对象监听

    Bromon原创 请尊重版权

           有非常多的时候,我们希望自己的程序能够监视数据的变化,然后做出响应,这种情况非常多,比如探测数据库中数据的变化、检测用户状态的变化等等。通常我们都缺乏一种双工通信的机制,只能选择让程序做论询,隔一段时间检测一次数据变化,记录下来与上一次检测结果做对比,从而判断数据是否发生了变化。毫无疑问这样的方式很笨拙,不仅写起来痛苦,跑起来也耗资源,是典型的用80%的时间解决20%的问题。

           观察者(Observer)是一种模式,也是Java中的一个API,它让一个值对象(Value Object)具备自省的功能,当他发现自己的状态改变了,就向相关的对象发送消息,这样的监听方式当然比轮询好。我感冒了自己会去医院,用不着医生每个月来问一次。禽兽·宇枫曾经给了我一段麻将游戏的服务器端代码,本来是让我研究一下麻将的算法,但是却被其中Observer的使用所吸引,这样写出来的服务器执行效率很高。我曾经用线程池+反射+观察者写了一个即时消息的服务器,既有socket的方便也具备udp的高效,可惜后来因为大幅修改设计代码作废了,不过观察者还是值得研究。

           JavaObserver API是对观察者模式的一个实现。假设我们有一个对象容器,其中存放用户消息,我希望这个容器自省,当有新的消息进来就自动触发观察者作出响应。首先定义消息对象,是个很简单的值对象:

    package com.gwnet.smsMessenger.mm.bromon;

    public class Message

    {

    private int id;

    private String sender;

    private String receiver;

    private String content;

    private String time;

    //请自己实现set/get方法,比如:

    public int getId()

    {

             return id;

    }

    public void setId(int id)

    {

    this.id=id;

    }

    }

    然后写一个存放Message的容器,容器使用ArrayList来存放对象是个很好的选择,也很简单:

    /*

    * Created on 2004-8-11

    */

    package com.gwnet.smsMessenger.mm.bromon;

    import java.util.*;

    /**

    * @author Bromon

    */

    public class MessageList extends Observable

    {

        private List m=new ArrayList();

        private static MessageList ml=null;

        

        public MessageList()

        {

        }

        

        public static MessageList getInstance()

        {

            if(ml==null)

           {

               ml=new MessageList();

           }

            return ml;

        }

        

        public void add(Message msg)

        {

            m.add(msg);

            super.setChanged();

            super.notifyObservers(m);

        }

        

        public void del(Message msg)

        {

            m.remove(msg);

        }

    }

    这个类继承了Observable类,并且对其中的add方法做了手脚,很明显,add方法的作用是向ArrayList容器中放入一个对象,这正是我们想监听的操作,所以有了:

    uper.setChanged();

    super.notifyObservers(m);

    这意思是一旦调用add方法,这个类自己就会向所有注册过的观察者发送消息,消息内容是什么呢?内容就是m,是存放消息的容器,观察者可以收到这个改变了状态的容器,然后对它进行操作,从而实现了对容器的监听,当然,我们只实现了对add方法的监听,你也可以试试其他的。

    需要特别注意的是这是一个不完整的单例类,写成单例是为了要保证整个jvm中只有这一个存放消息的容器,而不写成完整的单例,原因是将来可能要提供另外的实例化方法。所以理解起来可能稍微难一点,大家可以参考一下设计模式中的单例模式。

    下面就是编写观察者并且注册它:

    /*

    * Created on 2004-8-11

    */

    package com.gwnet.smsMessenger.bromon;

    import java.util.*;

    /**

    * @author Bromon

    */

    public class MessageObserver implements Observer

    {

        /* (non-Javadoc)

         * @see java.util.Observer#update(java.util.Observable, java.lang.Object)

         */

        public void update(Observable arg0, Object arg1)

        {

           List l=(List)arg1;

            Message m=(Message)l.get(l.size()-1);

            String receiver=m.getReceiver();

            System.out.println("给"+m.getReceiver()+”的新消息:”+m.getContent());

        }

    }

    这个类继承Oberver接口,update(Observable,Object)是必须提供的方法,在这个方法中我们接收被观察类传过来的数据(含有消息的容器),然后取出其中最后一个,读取它的内容。

    Java里的观察者使用起来是非常简单的。我们的例子好处是所有的操作都在内存中进行,而且不需要轮询,效率非常高,缺点是一旦当机内存中的数据就丢失了,所以如果有一套比较完善的对象缓冲机制,就可以应付复杂的应用,写出高效简洁的多线程服务器。

    展开全文
  • 使用观察者Obderver实现对象监控

    千次阅读 2006-01-16 17:40:00
    Bromon原创 请尊重版权 有非常多时候,我们希望自己的程序能够监视数据变化,然后做出响应,这种情况非常多,比如探测数据库中数据变化、检测用户状态变化等等。通常我们都缺乏一种双工通信机制,只能...
    Bromon原创 请尊重版权 
           有非常多的时候,我们希望自己的程序能够监视数据的变化,然后做出响应,这种情况非常多,比如探测数据库中数据的变化、检测用户状态的变化等等。通常我们都缺乏一种双工通信的机制,只能选择让程序做论询,隔一段时间检测一次数据变化,记录下来与上一次检测结果做对比,从而判断数据是否发生了变化。毫无疑问这样的方式很笨拙,不仅写起来痛苦,跑起来也耗资源,是典型的用80%的时间解决20%的问题。
           观察者(Observer)是一种模式,也是Java中的一个API,它让一个值对象(Value Object)具备自省的功能,当他发现自己的状态改变了,就向相关的对象发送消息,这样的监听方式当然比轮询好。我感冒了自己会去医院,用不着医生每个月来问一次。禽兽·宇枫曾经给了我一段麻将游戏的服务器端代码,本来是让我研究一下麻将的算法,但是却被其中Observer的使用所吸引,这样写出来的服务器执行效率很高。我曾经用线程池+反射+观察者写了一个即时消息的服务器,既有socket的方便也具备udp的高效,可惜后来因为大幅修改设计代码作废了,不过观察者还是值得研究。
           Java的Observer API是对观察者模式的一个实现。假设我们有一个对象容器,其中存放用户消息,我希望这个容器自省,当有新的消息进来就自动触发观察者作出响应。首先定义消息对象,是个很简单的值对象:
    package com.gwnet.smsMessenger.mm.bromon; 
    public class Message 

    private int id; 
    private String sender; 
    private String receiver; 
    private String content; 
    private String time; 
    //请自己实现set/get方法,比如: 
    public int getId() 

             return id; 


    public void setId(int id) 

    this.id=id; 




    然后写一个存放Message的容器,容器使用ArrayList来存放对象是个很好的选择,也很简单:

    /* 
    * Created on 2004-8-11 
    */ 
    package com.gwnet.smsMessenger.mm.bromon; 
    import java.util.*; 
    /** 
    * @author Bromon 
    */ 
    public class MessageList extends Observable 

        private List m=new ArrayList(); 
        private static MessageList ml=null; 
     
        public MessageList() 
        { 
        } 
        public static MessageList getInstance() 
        { 
            if(ml==null) 
           { 
               ml=new MessageList(); 
           } 

            return ml; 
        } 

        public void add(Message msg) 
       { 
            m.add(msg); 
            super.setChanged(); 
            super.notifyObservers(m); 
        } 


        public void del(Message msg) 

        { 
            m.remove(msg); 
        } 




    这个类继承了Observable类,并且对其中的add方法做了手脚,很明显,add方法的作用是向ArrayList容器中放入一个对象,这正是我们想监听的操作,所以有了:
    uper.setChanged(); 
    super.notifyObservers(m); 
    这意思是一旦调用add方法,这个类自己就会向所有注册过的观察者发送消息,消息内容是什么呢?内容就是m,是存放消息的容器,观察者可以收到这个改变了状态的容器,然后对它进行操作,从而实现了对容器的监听,当然,我们只实现了对add方法的监听,你也可以试试其他的。 
    需要特别注意的是这是一个不完整的单例类,写成单例是为了要保证整个jvm中只有这一个存放消息的容器,而不写成完整的单例,原因是将来可能要提供另外的实例化方法。所以理解起来可能稍微难一点,大家可以参考一下设计模式中的单例模式。
    下面就是编写观察者并且注册它:
    /* 
    * Created on 2004-8-11 
    */ 
    package com.gwnet.smsMessenger.bromon; 
    import java.util.*; 
    /** 
    * @author Bromon 
    */ 
    public class MessageObserver implements Observer 

        /* (non-Javadoc) 
         * @see java.util.Observer#update(java.util.Observable, java.lang.Object) 
         */ 
        public void update(Observable arg0, Object arg1) 
        { 
           List l=(List)arg1; 
            Message m=(Message)l.get(l.size()-1); 
            String receiver=m.getReceiver(); 
            System.out.println("给"+m.getReceiver()+”的新消息:”+m.getContent()); 
        } 

    这个类继承Oberver接口,update(Observable,Object)是必须提供的方法,在这个方法中我们接收被观察类传过来的数据(含有消息的容器),然后取出其中最后一个,读取它的内容。 
    Java里的观察者使用起来是非常简单的。我们的例子好处是所有的操作都在内存中进行,而且不需要轮询,效率非常高,缺点是一旦当机内存中的数据就丢失了,所以如果有一套比较完善的对象缓冲机制,就可以应付复杂的应用,写出高效简洁的多线程服务
    展开全文
  • 观察者模式定义了一种一对多的依赖关系,让多个...能够达到这种要求的可行性方案很多,但是为了能够使代码易于复用,应该选择低耦合度的设计方案,我们需要考虑使这些低耦合度的对象之间能够维持行动的协调一致。这就

    观察者模式定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时,会通知所有观察者对象,使它们能够自动更新自己。

    观察者模式所涉及的角色有以下四个:
    抽象主题(Subject)角色:抽象主题角色把所有对观察者对象的引用保存在一个集合(比如ArrayList对象)里,每个主题都可以有任何数量的观察者。抽象主题提供一个接口,可以增加和删除观察者对象,在我们安卓开发中,我通常把这个抽象主题角色定义为application。

    具体主题(ConcreteSubject)角色:将有关状态存入具体观察者对象;在具体主题的内部状态改变时,给所有登记过的观察者发出通知。其实就是执行通知观察者更新状态的角色。

    抽象观察者(Observer)角色:为所有的具体观察者定义一个接口,这个接口叫做更新接口。

    具体观察者(ConcreteObserver)角色:存储与主题的状态自恰的状态,实现抽象观察者角色所要求的更新接口,在相应的抽象方法中去进行必要的操作,以便使本身的状态与主题的状态相协调。

    抽象主题角色:

     public class MyApplication extends Application{
        private static MyApplication instance = null;
        private List<EcgObserver> observers = new ArrayList<EcgObserver>();
        @Override
        public void onCreate() {
           super.onCreate();
           instance=this;
        }
         /**
         * 静态工厂方法
         */
       public synchronized static MyApplication getInstance() {
           return instance;
        }
        /**
         * 添加
         * @param ecg
         */
       public void addEcgObserver(EcgObserver ecg) {
           if (ecg != null) {
               observers.clear();//先行全部清除
               observers.add(ecg);
           }
        }
    /**
     * 删除
     * @param ecg
     */
       public void delEcgObserver(EcgObserver ecg) {
           if (ecg != null) {
               observers.remove(ecg);
           }
        }
        /**
         * 刷新状态
         * @param state
         * @param msg
         */
       public void notifyEcgState(int state, String msg) {
           try {
               for (EcgObserver ecg : observers) {
                  ecg.onEcgStateChange(state, msg);
               }
           } catch (Exception ex) {
               ex.printStackTrace();
           }
        }
    }

    具体主题角色:

    public class Test1 {
        public Test1() {
           super();
        }
        /**
         * 通知更新
         */
        private void notifyUpdate(){
           MyApplication.getInstance().notifyEcgState(1,"我的状态改变了!");
        }
    }

    抽象观察者角色:

    public interface EcgObserver {
        void onEcgStateChange(int state, String msg);
    }

    具体观察者角色:

    public class MainActivity extends Activity implements EcgObserver {
        @Override
        protected void onCreate(BundlesavedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
        HEApplication app = HEApplication.getInstance();
           app.addEcgObserver(this);
        }
        @Override
        public void onEcgStateChange(int state, String msg) {
           // 此处做需要更新的一些操作
        }
    } 

    如果我们想要控制每次通知更新的时候,都是在我们想要的activity中去更新,而其他的activity不更新,这样我们只需要,在进入这个activity中调用addEcgObserver(EcgObserverecg);退出的时候调用delEcgObserver(EcgObserverecg),这样就OK啦!

    以上就是我对java观察者模式的理解,不住之处还望大家指出。
    更多安卓相关信息,请扫码关注微信公众号:lifeAndroid
    这里写图片描述

    展开全文
  • 观察者模式 观察者模式也叫作发布-订阅模式,也就是...一个软件系统常常要求在某一个对象状态发生变化时,某些其他的对象作出相应的改变。能做到这一点的设计方案有很多,但是为了使系统能够易于复用,应该选择低耦...

    观察者模式

    观察者模式也叫作发布-订阅模式,也就是事件监听机制。观察者模式定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象,这个主题对象在状态上发生变化时,会通知所有观察者对象,使他们能够自动更新自己

     

    观察者模式的结构

    一个软件系统常常要求在某一个对象状态发生变化时,某些其他的对象作出相应的改变。能做到这一点的设计方案有很多,但是为了使系统能够易于复用,应该选择低耦合度的设计方案。减少对象之间的耦合有利于系统的复用,但是同时需要使这些低耦合度的对象之间能够维持行动的协调一致,保证高度的协作。观察者模式是满足这一要求的各种设计方案中最重要的一种。

    观察者模式所涉及的角色有:

    1、抽象主题角色

    抽象主题角色把所有对观察者对象的引用保存在一个集合中,每个主题都可以有任意数量的观察者。抽象主题提供一个接口,可以增加和删除观察者对象。

    2、具体主题角色

    将有关状态存入具体观察者对象,在具体主题的内部状态改变时,给所有登记过的观察者发出通知。

    3、抽象观察者角色

    为所有的具体观察者提供一个接口,在得到主题通知时更新自己

    4、具体观察者角色

    存储与主题的状态相关的状态。具体观察者角色实现抽象观察者角色所要求的更新接口,以便使本身的状态与主题的状态协调

     

    观察者模式实例

    抽象主题角色,有增加观察者、删除观察者、通知观察者的功能:

    复制代码

    public abstract class Subject
    {
        /** 用来保存注册的观察者对象 */
        private List<Observer> list = new ArrayList<Observer>();
        
        /** 注册观察者对象 */
        public void attch(Observer observer)
        {
            list.add(observer);
            System.out.println("Attached an observer");
        }
        
        /** 删除观察者对象 */
        public void detach(Observer observer)
        {
            list.remove(observer);
            System.out.println("Detached an observer");
        }
        
        /** 通知所有注册的观察者对象 */
        public void notifyObservers(String newState)
        {
            for (int i = 0; i < list.size(); i++)
            {
                list.get(i).update(newState);
            }
        }
    }

    复制代码

    具体主题角色,这个change方法放在子类中是因为可能不同的主题在改变观察者状态的时候会做一些不同的操作,因此就不统一放在父类Subject里面了:

    复制代码

    public class ConcreteSubject extends Subject
    {
        private String state;
        
        public String getState()
        {
            return state;
        }
        
        public void change(String newState)
        {
            state = newState;
            System.out.println("主题状态为:" + state);
            
            // 状态发生改变时,通知各个观察者
            this.notifyObservers(state);
        }
    }

    复制代码

    观察者接口:

    public interface Observer
    {
        void update(String state);
    }
    

    具体观察者实现了观察者接口:

    复制代码

    public class ConcreteObserver implements Observer
    {
        /** 观察者的状态 */
        private String observerState;
        
        public void update(String state)
        {
            /** 更新观察者的状态 */
            observerState = state;
            System.out.println("状态为:" + observerState);
        }
    }

    复制代码

    客户端调用代码,一旦主题调用了change方法改变观察者的状态,那么观察者Observer里面的observerState全都改变了:

    复制代码

    public static void main(String[] args)
    {
        /** 创建主题角色 */
        ConcreteSubject subject = new ConcreteSubject();
        
        /** 创建观察者对象 */
        Observer observer = new ConcreteObserver();
        
        /** 将观察者注册到主题对象上 */
        subject.attch(observer);
        
        /** 改变主题对象的状态 */
        subject.change("new state");
    }

    复制代码

    运行结果为:

    Attached an observer
    主题状态为:new state
    状态为:new state

    这里只添加了一个观察者,有兴趣的可以试试看多添加几个观察者,效果都是一样的,主题角色改变状态,观察者状态全变。

     

    观察者模式的两种模型

    1、推模型

    主题对象向观察者推送主题的详细信息,不管观察者是否需要。推送的信息通常是主题对象的全部或部分数据,上面的例子就是典型的推模型

    2、拉模型

    主题对象在通知观察者的时候,只传递少量信息。如果观察者需要更具体的信息,由观察者主动到主题对象中去获取,相当于是观察者从主题对象中拉数据。一般这种模型的实现中,会把主题对象自身通过update()方法传递给观察者,这样观察者在需要获取数据的时候,就可以通过这个引用来获取了。

     

    两种模型的比较

    1、推模型是假设主题对象知道观察者需要的数据,拉模型是假设主题对象不知道观察者需要什么数据,干脆把自身传递过去,让观察者自己按需要取值

    2、推模型可能会使得观察者对象难以复用,因为观察者的update()方法是按需要定义的参数,可能无法兼顾到没有考虑到的使用情况,这意味着出现新的情况时,可能要提供新的update()方法

     

    观察者模式在Java中的应用及解读

    JDK是有直接支持观察者模式的,就是java.util.Observer这个接口:

    复制代码

    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);
    }

    复制代码

    这就是观察者的接口,定义的观察者只需要实现这个接口就可以了。update()方法,被观察者对象的状态发生变化时,被观察者的notifyObservers()方法就会调用这个方法:

    复制代码

    public class Observable {
        private boolean changed = false;
        private Vector obs;
       
        /** Construct an Observable with zero Observers. */
    
        public Observable() {
        obs = new Vector();
        }
    
        /**
         * Adds an observer to the set of observers for this object, provided 
         * that it is not the same as some observer already in the set. 
         * The order in which notifications will be delivered to multiple 
         * observers is not specified. See the class comment.
         *
         * @param   o   an observer to be added.
         * @throws NullPointerException   if the parameter o is null.
         */
        public synchronized void addObserver(Observer o) {
            if (o == null)
                throw new NullPointerException();
        if (!obs.contains(o)) {
            obs.addElement(o);
        }
        }
        ...
    }

    复制代码

    这是被观察者的父类,也就是主题对象。这是一个线程安全的类,是基于Vector实现的。主题对象中有这些方法对观察者进行操作:

    方  法 作  用
    addObserver(Observer o) 如果观察者与集合中已有的观察者不同,则向对象的观察者集合中添加此观察者
    clearChanged()、hasChanged()、setChanged() 这三个方法算是一对,用来标记此观察者对象(主题对象)是否被改变的状态的
    countObservers() 返回观察者对象的数目
    deleteObserver(Observer o) 从对象的观察者集合中删除某个观察者
    deleteObservers() 清除观察者列表
    notifyObservers()、notifyObservers(Object arg) 如果本对象有变化则通知所有等级的观察者,调用update()方法

     

    利用JDK支持的主题/观察者的例子

    创建一个观察者:

    复制代码

    public class Watched extends Observable
    {
        private String data = "";
        
        public String getData()
        {
            return data;
        }
        
        public void setData(String data)
        {
            if (!this.data.equals(data))
            {
                this.data = data;
                setChanged();
            }
            notifyObservers();
        }
    }

    复制代码

    创建一个主题:

    复制代码

    public class Watcher implements Observer
    {
        String data;
    
        public Watcher(Observable o)
        {
            o.addObserver(this);
        }
        
        public String getData()
        {
            return data;
        }
        
        public void update(Observable o, Object arg)
        {
            this.data = ((Watched)o).getData();
            System.out.println("状态发生改变:" + ((Watched)o).getData());
        }
    }

    复制代码

    写一个main函数调用一下:

    复制代码

    public static void main(String[] args)
    {
        /** 创建被观察者对象 */
        Watched watched = new Watched();
        
        /** 创建观察者对象,并将被观察者对象登记 */
        Watcher watcher = new Watcher(watched);
        
        /** 给被观察者状态赋值 */
        watched.setData("start");
        watched.setData("run");
        watched.setData("stop");
    }

    复制代码

    运行结果为:

    状态发生改变:start
    状态发生改变:run
    状态发生改变:stop

    看到主题对象改变的时候,观察者对象的状态也随之改变

     

    观察者模式的优点以及实际应用

    引入设计模式最主要的作用我认为就是两点:

    1、去重复代码,使得代码更清晰、更易读、更易扩展

    2、解耦,使得代码可维护性更好,修改代码的时候可以尽量少改地方

    使用观察者模式可以很好地做到这两点。增加观察者,直接new出观察者并注册到主题对象之后就完事了,删除观察者,主题对象调用方法删除一下就好了,其余都不用管。主题对象状态改变,内部会自动帮我们通知每一个观察者,是不是很方便呢?

    观察者模式主要应用场景有:

    1、对一个对象状态的更新需要其他对象同步更新

    2、对象仅需要将自己的更新通知给其他对象而不需要知道其他对象的细节,如消息推送

    展开全文
  • 这个主题对象在状态发生变化时,会通知所有观察对象,使它们能够自动更新自己。 解决问题  将一个系统分割成一个一些类相互协作类有一个不好副作用,那就是需要维护相关对象一致性。我们不希望...
  • 观察对象则可以选择它感兴趣主题进行观察。 1、简单介绍 这里举一个简单例子来说明,在以前互联网还没有如此发达时候,运营商(中国移动、中国电信、中国联通)会给我们提供天气预报服务,我们通过...
  • 有非常多时候,我们希望自己的程序能够监视数据变化,然后做出响应,这种情况非常多,比如探测数据库中数据变化、检测用户状态变化等等。通常我们都缺乏一种双工通信机制,只能选择让程序做论询,隔一段...
  • ​ 一个软件系统常常要求在某一个对象的状态发生变化的时候,某些其它的对象做出相应的改变。做到这一点的设计方案有很多,但是为了使系统能够易于复用,应该选择低耦合度的设计方案。 ​ 减少对象之间的耦合有利于...
  • 一个软件系统常常要求在某一个对象的状态发生变化的时候,某些其它的对象做出相应的改变。做到这一点的设计方案有很多,但是为了使系统能够易于复用,应该选择低耦合度的设计方案。减少对象之间的耦合有利于系统的复
  • 在Update操作中,主体可以简单地将自己作为参数传递,从而让观察者知道要检查哪个主体。 主体和它的观察者依靠通知机制来保持一致。但实际上是什么对象调用Notify来触发更新呢?这里有两种选择。 让Subject上状态...
  • 2.3 拥护和疑虑:关于对象的争辩 2.4 小结 第3章 对象基础 3.1 类和对象 3.1.1 编写第一个类 3.1.2 第一个对象(或两个) 3.2 设置类中属性 3.3 使用方法 3.4 参数和类型 3.4.1 基本类型 3.4.2 获得提示:对象类型...
  • 多年以前,有一位名叫克里斯多佛·亚历山大(英文名Christopher Alexander)建筑师为了研究优秀设计有没有共性这一问题,他对建筑物、城镇、街道等,以及人类为自己所建造各种生活空间进行了大量的观察。...
  • 当做一款APP,需要选择本地图片时,首先考虑无疑是系统相册,但是Android手机五花八门,再者手机像素提升,大图无法返回等异常因数,导致适配机型比较困难,微信、QQ都相继自己的APP里集成了图片选择功能,...
  • 一个男人要在叁个女郎中选定一位作为结婚对象,他决定做一个测验,于是他给了每一位女郎美金五千元,并观察她们如何处理这笔钱.. 第一位女郎从头到脚重新打扮,她到一家美容沙龙设计了新发型,画了美丽妆,还买...
  • 常见设计模式

    2020-08-01 17:41:03
    单例模式:单例模式主要解决一个全局使用的类频繁的创建和销毁的问题。单例模式下可以确保某一...观察者模式:定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更
  • 在打开界面功能中,选择维护对象选项,找到事务,就可以看到Tcode了。 这样一来,如果在工作中好不容易从后台菜单中找到相应配置点,就可以不必记忆复杂路径;直接将事务进行收收藏即可。
  • Objetto是一个自以为是面向对象框架,用于构建模块化应用程序和API。 概述 Objetto允许创建一个,该由称为高级可变结构组成。 初始化时,与关联。 是父子树一部分。 由定义。 封装了自身不变子集版本...
  • 2020-11-21

    2020-11-21 12:04:03
    假设物体a是被观察者,它会有权力选择它的观察者们add(某个观察者)用于给观察者观看的权力,remove(某个观察者)用于取消其观察的权力,还需要有一个更新自己信息的方法,以及向观察者发送信息的方法。观察者们通过...
  • 个人感觉就是单例模式比较适合于工具类,也就是说这个类或者是一个对象而言是独一无二,但是工厂模式而言生产而言是创建出统一类型产品,选择性比较大 第二点就是线程安全这一方面:单例模式涉及到线程安全这一...
  • 面向对象计算始于这个基本概念,即现实世界可以被描绘成一系列完全自治、封装的对象,这些对象通过一个受保护的接口访问其他对象。 4. 多态性:  多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化...
  • 分类构建策略资产库**对系统化交易方法进行了良好抽象,包含了九大策略组件:市场环境判断策略、系统有效条件、信号指示器、止损/止盈策略、资金管理策略、盈利目标策略、移滑价差算法、交易对象选择策略、资金...
  • 1QT信号与槽1

    2018-12-17 23:57:58
    想写一篇Qt信号与槽,在网上找到了很多资料,最终选择了豆子Qt学习之路2这本书。里面大部分都是豆子,我只是负责 搬运,因为我也是Qt学习初学者。希望加油 信号槽 所谓信号槽,实际就是观察者模式。 当...

空空如也

空空如也

1 2 3 4 5 ... 12
收藏数 226
精华内容 90
关键字:

选择自己观察的对象