精华内容
下载资源
问答
  • 上次研究观察者模式,很多文章说它也叫Subscribe/Publish(发布/订阅模式)。可在《Javascript设计模式》一书中,这两...与Observer模式不同之处在于它允许任何订阅者执行适当的事件处理程序来注册和接收发布发出通知
  • 不管是维基百科还是百度百科,搜索观察者模式,都会发现观察者模式的定义是观察者模式(有时又被称为发布/订阅模式),即一个目标对象管理所有相依于它的观察者对象,并且在它本身的状态改变时主动发出通知。...

    [原]观察者模式与发布/订阅模式的区别

           

            不管是维基百科还是百度百科,搜索观察者模式,都会发现观察者模式的定义是观察者模式(有时又被称为发布/订阅模式),即一个目标对象管理所有相依于它的观察者对象,并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实作事件处理系统。最开始老师让我区别观察者模式与发布/订阅模式,简直无从下手。感觉明明就是一样的,而且《设计模式》书中也很明确地给出了观察者模式又称为发布/订阅模式,但是后来查了很多资料、也问了老师之后发现观察者模式与发布/订阅模式还是有区别的。

     

    (1)观察者模式本质上是一种对象行为模式,而 发布/订阅模式本质上是一种架构模式,强调组件的作用

    (2)观察者模式定义了对象间的一种一对多依赖关系,使得每当一个对象改变状态,则所有依赖于它的对象都会得到通知并采用一种机制实现自动更新。观察者模式的被观察者对象即目标对象中保留了观察者的集合,当被观察者对象的状态发生变化时,会遍历观察者对象集合,然后通知观察者对象得到更新。而发布/订阅模式并不保留观察者与被观察者之间的消息,类似一种生产者消费者问题。

     

    生产者把数据放入缓冲区,消费者从缓冲区取出数据。发布/订阅模式强调组件的作用,生产者通过组件将数据推(push)送到缓冲区,通过组件通知消费者是否选择将缓冲区的数据拉(pull)过来,即取出数据。发布/订阅模式很好地实现了解耦。比如彩信,在我们手机的客户端获取彩信短信后,并没有获取它的全部内容,当我们选择获取后,再从缓冲区里将我们希望获取的内容得到。

    (3)观察者模式多应用在单片机,而发布/订阅模式更多地在分布式环境中应用。

        

    转载于:https://www.cnblogs.com/cangqiongbingchen/p/5005254.html

    展开全文
  • 观察者模式

    2016-09-14 00:20:00
    通知者发出通知,各发布者则收到通知后做出相应的动作。由于存在不同的订阅者和通知者,所以将这两者抽象出来。 其实Subject和Observer是抽象类还是接口,这个是比较灵活的,取决于你的应用场景是怎样,总之就是...

    订阅者模式通常也成为发布-订阅模式,发布者也称为通知者,订阅者也称为观察者。通知者发出通知,各发布者则收到通知后做出相应的动作。由于存在不同的订阅者和通知者,所以将这两者抽象出来。

    其实Subject和Observer是抽象类还是接口,这个是比较灵活的,取决于你的应用场景是怎样,总之就是要将它们抽象出来,方便不同的通知者和观察者来实现它们。

    下面是代码实现。

    首先是Subject抽象通知者。

     1 package day_9_observer;
     2 
     3 import java.util.ArrayList;
     4 import java.util.List;
     5 
     6 /**
     7  * 抽象通知者类
     8  * @author turbo
     9  *
    10  * 2016年9月13日
    11  */
    12 public abstract class Subject {
    13     private List<Observer> observers = new ArrayList<Observer>();
    14     private String name;
    15     
    16     public String getName() {
    17         return name;
    18     }
    19     public void setName(String name) {
    20         this.name = name;
    21     }
    22     public Subject(String name){
    23         this.name = name;
    24     }
    25     /**
    26      * 新增观察者
    27      * @param observer
    28      */
    29     public void attach(Observer observer){
    30         observers.add(observer);
    31     }
    32     
    33     /**
    34      * 移除观察者
    35      * @param observer
    36      */
    37     public void detach(Observer observer){
    38         observers.remove(observer);
    39     }
    40     
    41     /**
    42      * 通知观察者
    43      */
    44     public void notifyObservers(){
    45         for (Observer observer : observers){
    46             observer.update();
    47         }
    48     }
    49 }

    接着是抽象观察者。

     1 package day_9_observer;
     2 
     3 /**
     4  * 抽象订阅者
     5  * @author turbo
     6  *
     7  * 2016年9月13日
     8  */
     9 public abstract class Observer {
    10     private String name;
    11     private Subject subject;
    12     
    13     public String getName() {
    14         return name;
    15     }
    16 
    17     public void setName(String name) {
    18         this.name = name;
    19     }
    20 
    21     public Subject getSubject() {
    22         return subject;
    23     }
    24 
    25     public void setSubject(Subject subject) {
    26         this.subject = subject;
    27     }
    28 
    29     public Observer(String name, Subject subject){
    30         this.name = name;
    31         this.subject = subject;
    32     }
    33     
    34     public abstract void update();
    35 }

    下面分别是具体的通知者和订阅者。

     1 package day_9_observer;
     2 
     3 /**
     4  * 具体通知者
     5  * @author turbo
     6  *
     7  * 2016年9月13日
     8  */
     9 public class ConcreteSubject extends Subject {
    10     /**
    11      * @param name
    12      */
    13     public ConcreteSubject(String name) {
    14         super(name);
    15     }
    16 
    17     private String action;        //这个在本例中并没有什么实际作用
    18 
    19     public String getAction() {
    20         return action;
    21     }
    22 
    23     public void setAction(String action) {
    24         this.action = action;
    25     }
    26     
    27 }
     1 package day_9_observer;
     2 
     3 /**
     4  * 具体观察者
     5  * @author turbo
     6  *
     7  * 2016年9月13日
     8  */
     9 public class ConcreteObserver extends Observer {
    10     /**
    11      * @param name
    12      * @param subject
    13      */
    14     public ConcreteObserver(String name, Subject subject) {
    15         super(name, subject);
    16     }
    17 
    18     /* (non-Javadoc)
    19      * @see day_9_observer.Observer#update()
    20      */
    21     @Override
    22     public void update() {
    23         System.out.println(super.getName() + "收到" + super.getSubject().getName() + "的通知");
    24     }
    25 
    26 }

    客户端代码。

     1 package day_9_observer;
     2 
     3 /**
     4  * 客户端
     5  * @author turbo
     6  *
     7  * 2016年9月13日
     8  */
     9 public class Main {
    10     
    11     public static void main(String[] args){
    12         ConcreteSubject concreteSubject = new ConcreteSubject("通知者");
    13         ConcreteObserver observer = new ConcreteObserver("订阅者", concreteSubject);
    14         
    15         concreteSubject.attach(observer);
    16         concreteSubject.notifyObservers();
    17     }
    18 }

    输出结果:

    这样我们就简单地完成了观察者模式。在《大话设计模式》中提到了,如果观察者是几个风马牛不相及的呢?我们现在是抽象成一个公共类,如果两个观察者无法抽象成一个公共类怎么办呢?《大话设计模式》中提到了利用“事件委托”来实现,由于此书是C#,但在Java中好像并没有线程的事件委托实现,在下一篇中会写利用“事件委托”来实现观察者模式,同样Java自带了Observer接口以提供对观察者模式的支持,下一篇我们也会利用JDK来实现观察者模式。

     

    展开全文
  • 目标是通知的发布者,它发出通知时并不需要知道谁是它的观察者。例如数据和图之间的关系,不管是折线图、饼状图、还是柱状图,它们都依赖于数据;当数据发生变化时,数据对象会通知依赖于它的对象去更新;所以...

    观察者模式(observer pattern)在对象之间定义一对多的依赖,这样一来,当一个对象改变状态,依赖它的对象都会收到通知,并自动更新。

    这种交互也称为发布-订阅(publish-subscribe)。目标是通知的发布者,它发出通知时并不需要知道谁是它的观察者。

    例如数据和图之间的关系,不管是折线图、饼状图、还是柱状图,它们都依赖于数据;当数据发生变化时,数据对象会通知依赖于它的对象去更新;所以就有了在Excel中,当数据发生变化时,对应的统计图也会自动的重绘。

    68f789b2adb45c8857aaab3b4fb76937.png

    Subject(主题)

    目标知道它的观察者。可以有任意多个观察者观察同一个目标;

    提供注册和删除观察者对象的接口。

    Observer(观察者)

    为那些在目标发生改变时需获得通知的对象定义一个更新接口。

    ConcreteSubject(具体主题)

    将有关状态存入各ConcreteObserver对象;

    当它的状态发生改变时,向它的各个观察者发出通知。

    ConcreteObserver(具体观察者)

    维护一个指向ConcreteSubject对象的引用;

    存储有关状态,这些状态应与目标的状态保持一致;

    实现Observer的更新接口以使自身状态与目标的状态保持一致。

    观察者模式按照以下方式进行协作:

    当ConcreteSubject发生任何可能导致其观察者与其本身状态不一致的改变时,它将通知它的各个观察者;

    在得到一个具体目标的改变通知后,ConcreteObserver对象可向目标对象查询信息。ConcreteObserver使用这些信息以使它的状态与目标对象的状态一致。

    以下是调用时序图:

    2cf15b7554126be09feb3c4fb0373938.png
    #include #include using namespace std;class Observer{public:     virtual void Update(int) = 0;};class Subject{public:     virtual void Attach(Observer *) = 0;     virtual void Detach(Observer *) = 0;     virtual void Notify() = 0;};class ConcreteObserver : public Observer{public:     ConcreteObserver(Subject *pSubject) : m_pSubject(pSubject){}     void Update(int value)     {          cout< m_ObserverList;     int m_iState;};void ConcreteSubject::Attach(Observer *pObserver){     m_ObserverList.push_back(pObserver);}void ConcreteSubject::Detach(Observer *pObserver){     m_ObserverList.remove(pObserver);}void ConcreteSubject::Notify(){     std::list::iterator it = m_ObserverList.begin();     while (it != m_ObserverList.end())     {          (*it)->Update(m_iState);          ++it;     }}int main(){     // Create Subject     ConcreteSubject *pSubject = new ConcreteSubject();     // Create Observer     Observer *pObserver = new ConcreteObserver(pSubject);     Observer *pObserver2 = new ConcreteObserver2(pSubject);     // Change the state     pSubject->SetState(2);     // Register the observer     pSubject->Attach(pObserver);     pSubject->Attach(pObserver2);     pSubject->Notify();     // Unregister the observer     pSubject->Detach(pObserver);     pSubject->SetState(3);     pSubject->Notify();     delete pObserver;     delete pObserver2;     delete pSubject;}/*Output:ConcreteObserver get the update. New State:2ConcreteObserver2 get the update. New State:2ConcreteObserver2 get the update. New State:3*/

    1 使用场合

    在许多设计中,经常涉及多个对象都对一个特殊对象中的数据变化感兴趣,而且这多个对象都希望跟踪那个特殊对象中的数据变化,也就是说当对象间存在一对多关系时,在这样的情况下就可以使用观察者模式。当一个对象被修改时,则会自动通知它的依赖对象。

    1.1 当一个抽象模型有两个方面,其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立的改变和复用;

    1.2 当对一个对象的改变需要同时改变其它对象,而不知道具体有多少对象有待改变;

    1.3 当一个对象必须通知其它对象,而它又不能假定其它对象是谁;也就是说,你不希望这些对象是紧密耦合的。

    观察者模式在实际项目的应用中非常常见,比如你到 ATM 机器上取钱,多次输错密码,卡就会被 ATM吞掉,吞卡动作发生的时候,会触发哪些事件呢?第一摄像头连续快拍,第二,通知监控系统,吞卡发生;第三,初始化 ATM 机屏幕,返回最初状态,你不能因为就吞了一张卡,整个 ATM 都不能用了吧,一般前两个动作都是通过观察者模式来完成的。观察者可以实现消息的广播,一个消息可以触发多个事件,这是观察者模式非常重要的功能。

    使用观察者模式也有两个重点问题要解决:

    广播链的问题

    如果你做过数据库的触发器,你就应该知道有一个触发器链的问题,比如表 A 上写了一个触发器,内容是一个字段更新后更新表 B 的一条数据,而表 B 上也有个触发器,要更新表 C,表 C 也有触发器…,完蛋了,这个数据库基本上就毁掉了!我们的观察者模式也是一样的问题,一个观察者可以有双重身份,即使观察者,也是被观察者,这没什么问题呀,但是链一旦建立,这个逻辑就比较复杂,可维护性非常差,根据经验建议,在一个观察者模式中最多出现一个对象既是观察者也是被观察者,也就是说消息最多转发一次(传递两次),这还是比较好控制的;

    异步处理问题

    被观察者发生动作了,观察者要做出回应,如果观察者比较多,而且处理时间比较长怎么办?那就用异步呗,异步处理就要考虑线程安全和队列的问题,这个大家有时间看看 Message Queue,就会有更深的了解。

    2 观察者模式的优缺点

    2.1 优点

    2.1.1 具体主题和具体观察者是松耦合关系。由于主题接口仅仅依赖于观察者接口,因此具体主题只是知道它的观察者是实现观察者接口的某个类的实例,但不需要知道具体是哪个类。同样,由于观察者仅仅依赖于主题接口,因此具体观察者只是知道它依赖的主题是实现主题接口的某个类的实例,但不需要知道具体是哪个类。

    2.1.2 观察者模式满足“开闭原则”。主题接口仅仅依赖于观察者接口,这样,就可以让创建具体主题的类也仅仅是依赖于观察者接口,因此,如果增加新的实现观察者接口的类,不必修改创建具体主题的类的代码。同样,创建具体观察者的类仅仅依赖于主题接口,如果增加新的实现主题接口的类,也不必修改创建具体观察者类的代码。

    2.2 缺点

    2.2.1 如果一个被观察者对象有很多的直接和间接的观察者的话,将所有的观察者都通知到会花费很多时间。

    2.2.2 如果在观察者和观察目标之间有循环依赖的话,观察目标会触发它们之间进行循环调用,可能导致系统崩溃。

    2.2.3 观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的,而仅仅只是知道观察目标发生了变化。

    3 总结

    实现观察者模式的时候要注意,观察者和被观察对象之间的互动关系不能体现成类之间的直接调用,否则就将使观察者和被观察对象之间紧密的耦合起来,从根本上违反面向对象的设计的原则。无论是观察者“观察”观察对象,还是被观察者将自己的改变“通知”观察者,都不应该直接调用。

    观察者模式在23 个设计模式中的地位是非常高的,我们基本上各大框架中都是随处可见。真正的理解了整个模式,对我们去理解别人的代码有非常大的帮助;在我们日后的工作中也会或多或少的使用该设计模式。

    -End-

    展开全文
  • 目标是通知的发布者,它发出通知时并不需要知道谁是它的观察者。例如数据和图之间的关系,不管是折线图、饼状图、还是柱状图,它们都依赖于数据;当数据发生变化时,数据对象会通知依赖于它的对象去更新;所以...

    观察者模式(observer pattern)在对象之间定义一对多的依赖,这样一来,当一个对象改变状态,依赖它的对象都会收到通知,并自动更新。

    这种交互也称为发布-订阅(publish-subscribe)。目标是通知的发布者,它发出通知时并不需要知道谁是它的观察者。

    例如数据和图之间的关系,不管是折线图、饼状图、还是柱状图,它们都依赖于数据;当数据发生变化时,数据对象会通知依赖于它的对象去更新;所以就有了在Excel中,当数据发生变化时,对应的统计图也会自动的重绘。

    4d3ab15ca08d9f0a4cd55ada49c66288.png

    Subject(主题)

    目标知道它的观察者。可以有任意多个观察者观察同一个目标;

    提供注册和删除观察者对象的接口。

    Observer(观察者)

    为那些在目标发生改变时需获得通知的对象定义一个更新接口。

    ConcreteSubject(具体主题)

    将有关状态存入各ConcreteObserver对象;

    当它的状态发生改变时,向它的各个观察者发出通知。

    ConcreteObserver(具体观察者)

    维护一个指向ConcreteSubject对象的引用;

    存储有关状态,这些状态应与目标的状态保持一致;

    实现Observer的更新接口以使自身状态与目标的状态保持一致。

    观察者模式按照以下方式进行协作:

    当ConcreteSubject发生任何可能导致其观察者与其本身状态不一致的改变时,它将通知它的各个观察者;

    在得到一个具体目标的改变通知后,ConcreteObserver对象可向目标对象查询信息。ConcreteObserver使用这些信息以使它的状态与目标对象的状态一致。

    以下是调用时序图:

    2040b5ef6ee4a034c55c4600cd730e9a.png
    #include #include using namespace std;class Observer{public:     virtual void Update(int) = 0;};class Subject{public:     virtual void Attach(Observer *) = 0;     virtual void Detach(Observer *) = 0;     virtual void Notify() = 0;};class ConcreteObserver : public Observer{public:     ConcreteObserver(Subject *pSubject) : m_pSubject(pSubject){}     void Update(int value)     {          cout< m_ObserverList;     int m_iState;};void ConcreteSubject::Attach(Observer *pObserver){     m_ObserverList.push_back(pObserver);}void ConcreteSubject::Detach(Observer *pObserver){     m_ObserverList.remove(pObserver);}void ConcreteSubject::Notify(){     std::list::iterator it = m_ObserverList.begin();     while (it != m_ObserverList.end())     {          (*it)->Update(m_iState);          ++it;     }}int main(){     // Create Subject     ConcreteSubject *pSubject = new ConcreteSubject();     // Create Observer     Observer *pObserver = new ConcreteObserver(pSubject);     Observer *pObserver2 = new ConcreteObserver2(pSubject);     // Change the state     pSubject->SetState(2);     // Register the observer     pSubject->Attach(pObserver);     pSubject->Attach(pObserver2);     pSubject->Notify();     // Unregister the observer     pSubject->Detach(pObserver);     pSubject->SetState(3);     pSubject->Notify();     delete pObserver;     delete pObserver2;     delete pSubject;}/*Output:ConcreteObserver get the update. New State:2ConcreteObserver2 get the update. New State:2ConcreteObserver2 get the update. New State:3*/

    1 使用场合

    在许多设计中,经常涉及多个对象都对一个特殊对象中的数据变化感兴趣,而且这多个对象都希望跟踪那个特殊对象中的数据变化,也就是说当对象间存在一对多关系时,在这样的情况下就可以使用观察者模式。当一个对象被修改时,则会自动通知它的依赖对象。

    1.1 当一个抽象模型有两个方面,其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立的改变和复用;

    1.2 当对一个对象的改变需要同时改变其它对象,而不知道具体有多少对象有待改变;

    1.3 当一个对象必须通知其它对象,而它又不能假定其它对象是谁;也就是说,你不希望这些对象是紧密耦合的。

    观察者模式在实际项目的应用中非常常见,比如你到 ATM 机器上取钱,多次输错密码,卡就会被 ATM吞掉,吞卡动作发生的时候,会触发哪些事件呢?第一摄像头连续快拍,第二,通知监控系统,吞卡发生;第三,初始化 ATM 机屏幕,返回最初状态,你不能因为就吞了一张卡,整个 ATM 都不能用了吧,一般前两个动作都是通过观察者模式来完成的。观察者可以实现消息的广播,一个消息可以触发多个事件,这是观察者模式非常重要的功能。

    使用观察者模式也有两个重点问题要解决:

    广播链的问题

    如果你做过数据库的触发器,你就应该知道有一个触发器链的问题,比如表 A 上写了一个触发器,内容是一个字段更新后更新表 B 的一条数据,而表 B 上也有个触发器,要更新表 C,表 C 也有触发器…,完蛋了,这个数据库基本上就毁掉了!我们的观察者模式也是一样的问题,一个观察者可以有双重身份,即使观察者,也是被观察者,这没什么问题呀,但是链一旦建立,这个逻辑就比较复杂,可维护性非常差,根据经验建议,在一个观察者模式中最多出现一个对象既是观察者也是被观察者,也就是说消息最多转发一次(传递两次),这还是比较好控制的;

    异步处理问题

    被观察者发生动作了,观察者要做出回应,如果观察者比较多,而且处理时间比较长怎么办?那就用异步呗,异步处理就要考虑线程安全和队列的问题,这个大家有时间看看 Message Queue,就会有更深的了解。

    2 观察者模式的优缺点

    2.1 优点

    2.1.1 具体主题和具体观察者是松耦合关系。由于主题接口仅仅依赖于观察者接口,因此具体主题只是知道它的观察者是实现观察者接口的某个类的实例,但不需要知道具体是哪个类。同样,由于观察者仅仅依赖于主题接口,因此具体观察者只是知道它依赖的主题是实现主题接口的某个类的实例,但不需要知道具体是哪个类。

    2.1.2 观察者模式满足“开闭原则”。主题接口仅仅依赖于观察者接口,这样,就可以让创建具体主题的类也仅仅是依赖于观察者接口,因此,如果增加新的实现观察者接口的类,不必修改创建具体主题的类的代码。同样,创建具体观察者的类仅仅依赖于主题接口,如果增加新的实现主题接口的类,也不必修改创建具体观察者类的代码。

    2.2 缺点

    2.2.1 如果一个被观察者对象有很多的直接和间接的观察者的话,将所有的观察者都通知到会花费很多时间。

    2.2.2 如果在观察者和观察目标之间有循环依赖的话,观察目标会触发它们之间进行循环调用,可能导致系统崩溃。

    2.2.3 观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的,而仅仅只是知道观察目标发生了变化。

    3 总结

    实现观察者模式的时候要注意,观察者和被观察对象之间的互动关系不能体现成类之间的直接调用,否则就将使观察者和被观察对象之间紧密的耦合起来,从根本上违反面向对象的设计的原则。无论是观察者“观察”观察对象,还是被观察者将自己的改变“通知”观察者,都不应该直接调用。

    观察者模式在23 个设计模式中的地位是非常高的,我们基本上各大框架中都是随处可见。真正的理解了整个模式,对我们去理解别人的代码有非常大的帮助;在我们日后的工作中也会或多或少的使用该设计模式。

    -End-

    展开全文
  • 作为设计模式之一,观察者模式有必要提前了解一下。...目标是通知的发布者,他发出通知的时候并不需要知道谁是他的观察者。(最后这一句话之后可能会有歧义出现,之后再讲。先记一下。) 还是用例子解释比较简单一点...
  • 目标是通知的发布者,它发出通知时并不需要知道谁是它的观察者。 再说说上面的数据和图之间的关系;不管是折线图、饼状图,还是柱状图,它们都依赖于数据;当数据发生变化时,数据对象会通知依赖于它的对象去更新;...
  •   观察者模式:又称发布订阅模式,当一个目标物件管理所有相依于它的观察者物件,并且在它本身的状态改变时主动发出通知。【引自百度百科】  这里的目标物件,就是被观察者,当它的状态发生变更时,需要去通知...
  • 在此种模式中,一个目标对象管理所有相依于它的观察者对象,并且在它本身的状态改变时主动发出通知。 这通常透过呼叫各观察者所提供的方法来实现。 实现观察者模式的时候要注意,观察者和被观察对象之间的互动关系不...
  • BasicUserNotification.m

    2019-07-30 15:04:31
    点击通知后,默认会自动打开发出通知的App 4.远程推送通知 在联网的情况下,由远程服务器推送给客户端的通知,又称APNs(Apple Push Notification Services) 不管应用是打开还是关闭的情况下,都能接收到服务器推送...
  • 但一直不知道别人有没有安装,或者安装后有没有卸载,因为我本身也没有程序里面写一个安装卸载的监控(其实还是有必要的,当用户安装或者删除你的插件时,向你发一个通知,并且可以给用户一个表单用来提交原因,当然...
  • DingTalk_v3.5.0

    2019-01-05 15:39:09
    无论是一对一聊天,还是一对多的群消息,钉钉让用户都能知道发出的消息对方是否阅读,哪些人已阅,哪些人未读。 2.用户发送信息后,消息旁显示“n人未读”,尤其是在群里发布信息(钉钉支持1500人大群),点击“n人...
  • anyboard神州建站系统

    2003-01-09 00:00:00
    操作系统:Windows NT/2000, Linux, Solaris, Other UNIX 服务器:Apache, MS IIS, Netscape Server, and ... 不论是对用户还是管理员,AnyBoard都给他们提供了丰富、可靠的功能。AnyBoard易用、安全、快速、稳定。
  • realplayer

    2010-08-18 10:57:02
    当 RN 准备发布此“软件”的商业版本时,RN 在任何时候都可以保留不发布本软件的商业版本的权利,或者一经发布,则保留改变其功能、规格、性能、作用、许可条款、发行日期、一般利用率或其它商业版本特性的权利。...
  •  本书涵盖了android开发从概念、技术到市场推广应用的全部话题,内容包括:android概览、android应用程序设计精髓、android用户界面设计精髓、常用android api、更多android应用程序设计原则、对外发布你的android...
  • java基础题 很全面

    2009-05-09 09:24:24
    61. 是否可以从一个static方法内部发出对非static方法的调用? 14 62. 写clone()方法时,通常都有一行代码,是什么? 14 63. 在JAVA中,如何跳出当前的多重嵌套循环? 14 64. List、Map、Set三个接口,存取元素时,各有什么...
  • 其逼真的书刊效果,翻动页面还会发出唰唰的声音;动感十足的图文,点击书上的小人还能开口说话;曼妙的背景音乐、精彩的视频、三维的图像……无不给人以惊艳的阅读体验。 多媒体杂志还具有无刊号之困扰、无印刷之...
  • 9月19日,北京131便利店发出通知,公司因资金周转问题不能正常经营;而邻家在倒闭后,亿欧曾报道称有独家消息人士透露,邻家目前每月亏损在500万左右,因为持续亏损,缺乏造血能力;同时股东善林金融的P2P业务爆雷,...
  • java面试宝典

    2013-02-28 16:04:01
    34、是否可以从一个static 方法内部发出对非static 方法的调用? 11 35、写clone()方法时,通常都有一行代码,是什么? 11 36、GC 是什么? 为什么要有GC? 11 37、垃圾回收的优点和原理。并考虑2 种回收机制。 11 38...
  • 千方百计笔试题大全

    2011-11-30 21:58:33
    34、是否可以从一个static 方法内部发出对非static 方法的调用? 11 35、写clone()方法时,通常都有一行代码,是什么? 11 36、GC 是什么? 为什么要有GC? 11 37、垃圾回收的优点和原理。并考虑2 种回收机制。 11 38...
  • 最新Java面试宝典pdf版

    热门讨论 2011-08-31 11:29:22
    13、是否可以从一个static方法内部发出对非static方法的调用? 12 14、Integer与int的区别 13 15、Math.round(11.5)等於多少? Math.round(-11.5)等於多少? 13 16、下面的代码有什么不妥之处? 13 17、请说出作用域...
  • Java面试宝典-经典

    2015-03-28 21:44:36
    13、是否可以从一个static方法内部发出对非static方法的调用? 12 14、Integer与int的区别 13 15、Math.round(11.5)等於多少? Math.round(-11.5)等於多少? 13 16、下面的代码有什么不妥之处? 13 17、请说出作用域...
  • Java面试宝典2010版

    2011-06-27 09:48:27
    13、是否可以从一个static方法内部发出对非static方法的调用? 14、Integer与int的区别 15、Math.round(11.5)等於多少? Math.round(-11.5)等於多少? 16、下面的代码有什么不妥之处? 17、请说出作用域public,...
  • Java面试宝典2012版

    2012-12-03 21:57:42
    13、是否可以从一个static方法内部发出对非static方法的调用? 12 14、Integer与int的区别 13 15、Math.round(11.5)等於多少? Math.round(-11.5)等於多少? 13 16、下面的代码有什么不妥之处? 13 17、请说出作用...
  • java面试宝典2012

    2012-12-16 20:43:41
    13、是否可以从一个static方法内部发出对非static方法的调用? 13 14、Integer与int的区别 13 15、Math.round(11.5)等於多少? Math.round(-11.5)等於多少? 14 16、下面的代码有什么不妥之处? 14 17、请说出作用域...
  • 13、是否可以从一个static方法内部发出对非static方法的调用? 12 14、Integer与int的区别 13 15、Math.round(11.5)等於多少? Math.round(-11.5)等於多少? 13 16、下面的代码有什么不妥之处? 13 17、请说出作用域...
  • Java面试笔试资料大全

    热门讨论 2011-07-22 14:33:56
    13、是否可以从一个static方法内部发出对非static方法的调用? 12 14、Integer与int的区别 13 15、Math.round(11.5)等於多少? Math.round(-11.5)等於多少? 13 16、下面的代码有什么不妥之处? 13 17、请说出作用域...
  • Java面试宝典2012新版

    2012-06-26 19:20:00
    13、是否可以从一个static方法内部发出对非static方法的调用? 12 14、Integer与int的区别 13 15、Math.round(11.5)等於多少? Math.round(-11.5)等於多少? 13 16、下面的代码有什么不妥之处? 13 17、请说出作用域...

空空如也

空空如也

1 2 3
收藏数 51
精华内容 20
关键字:

发出通知还是发布通知