android Observer(观察者模式)_案例祥解
Observer模式在Android应用程序中的实际应用

Observer模式在Android应用程序中的实际应用在Android应用程序中,常常需要同时响应多个事件。
例如,如果一个应用程序需要支持多语言环境,那么用户在更改语言设置后,应用程序应该能够及时地刷新界面。
此时,就可以使用Observer模式来实现事件的处理。
Observer模式是一种行为型设计模式,它可以将对象之间的一对多依赖关系分离出来,使得一个对象的状态改变可以触发多个其他对象的更新操作。
在Android应用程序中,Observer模式通常被用来处理Model-View-Controller(MVC)模式中的数据模型部分,具体实现过程如下:首先,需要定义一个被观察者对象(Observable)来存储数据模型,该对象可以维护一个观察者列表,当数据模型发生变化时,它会通知所有观察者对象执行更新操作。
在Android应用程序中,常用的被观察者对象包括ContentProvider、SharedPreferences、LiveData等。
其次,需要定义一个观察者对象(Observer)来响应被观察者的通知,并执行相应的操作。
在Android应用程序中,常用的观察者对象包括Activity、Fragment、Service等。
当观察者对象被通知到数据模型变化时,它会调用其内部的update方法,以执行具体的更新操作。
例如,在多语言环境下,Activity可以通过监听SharedPreferences中的语言设置值来刷新界面上的文字显示。
最后,在Android应用程序中,可以使用Android的LiveData 类来实现Observer模式的具体实现过程。
LiveData是一种可观察的数据持有类,它可以通过观察者-被观察者的方式,实时更新UI 界面。
具体应用过程如下:定义LiveData对象通过定义LiveData对象,我们可以观察数据变化,然后及时刷新UI界面。
例如,在ViewModel中定义LiveData对象:public class MainViewModel extends ViewModel {private MutableLiveData<String> mLanguage;public MainViewModel() {mLanguage = new MutableLiveData<>();}public MutableLiveData<String> getLanguage() {return mLanguage;}public void setLanguage(String language) {mLanguage.setValue(language);}}观察LiveData对象我们可以在Activity或Fragment中,使用observe方法来观察LiveData对象的变化,以便在数据模型变化时及时更新UI界面。
观察者模式的例子

观察者模式的例子
观察者模式的例子
观察者模式是一个十分常见的设计模式,它可以帮助我们从被观察的
对象中获取信息,并在需要时自动通知我们。
本篇文章将通过几个具
体的例子来介绍观察者模式。
一、新闻订阅
假设我们有一个新闻网站,用户可以选择订阅自己感兴趣的新闻主题,如政治、体育、娱乐等。
当我们有新的相关新闻时,应该如何通知已
订阅该主题的用户呢?这时观察者模式就可以充分发挥作用。
我们可
以把网站的用户看作观察者,而每个订阅主题可以看作一个被观察者,当被观察者发生变化时(如新闻更新),通知所有观察者即可。
二、股票市场
另一个例子是股票市场,投资者需要及时了解股票的价格变化。
我们
可以把每只股票看作一个被观察者,而每个投资者可以看作观察者。
当股票价格发生变化时,被观察者可以通过观察者模式通知所有观察者,投资者们就可以第一时间了解到相关信息。
三、自定义通知
观察者模式还可以用于自定义通知,例如某个人可以设置自己的日程
安排,并让自己的亲属和朋友作为观察者,当日程安排发生变化时,
观察者将自动收到通知,以便及时作出应对。
总结
观察者模式可以用于任何需要监控变化的场景,它将被观察者和观察
者解耦,使得系统更加灵活和可扩展。
在实际应用中,我们需要关注
以下几点:
1. 确定被观察者和观察者之间的关系,并定义相应的接口;
2. 当被观察者状态发生变化时,通知所有观察者;
3. 观察者根据通知的内容作出相应的处理。
观察者模式虽然简单,但是在系统的设计和开发中发挥着重要的作用。
希望读者们能够多加关注和实践!。
Android使用观察者模式Observer实现网络状态监听

Android使⽤观察者模式Observer实现⽹络状态监听在Android开发过程中,很多时候都会⽤到当前⽹络的状态判断以及⽹络状况发⽣变化的时候做出相应的反应,要想监听⽹络状态,⽤观察者模式再合适不过了,废话不多说,直接上代码。
观察者模式属于⾯向对象的23中设计模式之⼀,不了解的同学请⾃⾏Google既然⽤观察者模式,⾃然离不开观察者模式⾥最重要的两个类Subject和Ovserver了Subjcet接⼝:/*** Description: observer subject* author: Wang* date: 11/28/16 11:19 AM** Copyright©2016 by wang. All rights reserved.*/public interface NetConnectionSubject {/*** 注册观察者** @param observer*/public void addNetObserver(NetConnectionObserver observer);/*** 移除观察者** @param observer*/public void removeNetObserver(NetConnectionObserver observer);/*** 状态更新通知** @param type*/public void notifyNetObserver(int type);}Observer接⼝:/*** Description: observer* author: Wang* date: 11/28/16 11:20 AM** Copyright©2016 by wang. All rights reserved.*/public interface NetConnectionObserver {/*** 通知观察者更改状态** @param type*/public void updateNetStatus(int type);}在Android⾥,最适合实现Subject类的,莫过于Application了,因为它全局唯⼀⽽且⽣命周期就是这个App的⽣命周期:/*** Description: App's application should extend this class* author: Wang* date: 11/28/16 10:34 AM** Copyright©2016 by wang. All rights reserved.*/public abstract class BaseApplication extends Application implements NetConnectionSubject {protected static BaseApplication instance;private int currentNetType = -1;private List<NetConnectionObserver> observers = new ArrayList<>();public static BaseApplication getInstance() {return instance;}/*** current net connection type** @return*/public int getCurrentNetType() {return currentNetType;}/*** current net connection status** @return*/public boolean isNetConnection() {return currentNetType == _NO_CONNECTION ? false : true;}@Overridepublic void onCreate() {super.onCreate();instance = this;currentNetType = NetWorkUtil.getConnectionType(this);}@Overridepublic void addNetObserver(NetConnectionObserver observer) {if (!observers.contains(observer)) {observers.add(observer);}}@Overridepublic void removeNetObserver(NetConnectionObserver observer) {if (observers != null && observers.contains(observer)) {observers.remove(observer);}}@Overridepublic void notifyNetObserver(int type) {/*** 避免多次发送相同的⽹络状态*/if (currentNetType == type) {return;} else {currentNetType = type;if (observers != null && observers.size() > 0) {for (NetConnectionObserver observer : observers) {observer.updateNetStatus(type);}}}}}具体谁要实现Observer接⼝,就要看具体场景了,这⾥以Activity为栗⼦吧:/*** Description: TODO* author: WangKunHui* date: 16/12/30 下午3:08* <p>* Copyright©2016 by wang. All rights reserved.*/public class TestActivity extends Activity implements NetConnectionObserver {@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);/**省略⼀些⽅法**/BaseApplication.getInstance().addNetObserver(this);}@Overridepublic void updateNetStatus(int type) {//当监听⽹络状态发⽣变化这⾥会及时的收到回馈}@Overrideprotected void onDestroy() {super.onDestroy();BaseApplication.getInstance().removeNetObserver(this);}}这⾥有个地⽅⼀定要注意:当Activity销毁的时候,⼀定要把这个观察者从观察者队列⾥移除掉!否者会发⽣内存泄漏到这⾥,观察者模式已经写完了,谢谢收看。
android observable 的使用方法

android observable 的使用方法Android中的Observable是RxJava库的一部分,用于实现观察者模式。
可以将Observable看作一个被观察的对象,当其发生变化时,在使用它的类中的观察者能够收到通知并进行相应的操作。
以下是Android中使用Observable的步骤:1. 添加依赖项:在项目的build.gradle文件中添加以下依赖项:```groovyimplementation 'io.reactivex.rxjava2:rxjava:2.x.y' implementation 'io.reactivex.rxjava2:rxandroid:2.x.y'```其中x和y代表具体版本号。
2. 创建Observable对象:使用Observable类的静态方法创建Observable对象。
例如,可以使用Observable.create()方法创建一个Observable对象。
在create()方法中,需要定义具体的逻辑,即当Observable对象的状态发生变化时,应该如何通知观察者。
3. 添加观察者:使用Observable对象的subscribe()方法添加观察者。
subscribe()方法接收一个Observer对象作为参数,Observer是观察者模式中定义的接口,用于接收Observable对象发出的通知。
4. 接受通知:在Observer对象中实现相应的方法,用于接收Observable对象发出的通知或更新。
以下是一个使用Observable的简单示例:```javaimport io.reactivex.Observable;import io.reactivex.Observer;import io.reactivex.disposables.Disposable;public class MainActivity extends AppCompatActivity {@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(yout.activity_main);// 创建Observable对象,通过create()方法定义逻辑Observable<String> observable = Observable.create(emitter -> {// 发出一条通知emitter.onNext("Hello, World!");// 发出完成通知emitter.onComplete();});// 添加观察者observable.subscribe(new Observer<String>() {@Overridepublic void onSubscribe(Disposable d) {// 当观察者订阅时回调// 可以保存Disposable对象用于取消订阅}@Overridepublic void onNext(String s) {// 当Observable发出通知时回调// 处理Observable发出的数据Log.d("TAG", "onNext: " + s);}@Overridepublic void onError(Throwable e) {// 当Observable发生错误时回调}@Overridepublic void onComplete() {// 当Observable完成时回调}});}}```通过以上步骤,可以在Android中使用Observable实现观察者模式。
Observer(观察者模式)

观察者模式介绍
在系统的设计中,我们常常需要设计一个消息提示功能,让系统把 提示信息发送到客户端。做到这一点的设计方案可以是多种多样, 但是为了使系统能够易于复用,我们的设计应该遵守高内聚低耦合 的设计原则,而且减少对象之间的耦合有利于系统的复用。观察者 模式(Observer)是满足这一要求的各种设计方案中最重要的一种。 观察者模式定义对象间的一种一对多的依赖关系,当一个对象的状态 发生改变时, 所有依赖于它的对象都得到通知并被自动更新。
角色:观察者角色和被观察角色。
例子:想买房的人就是观察者(HousePriceObserver),要成为观察 者就要实现Observer接口,房子是被观察者(House),要成为被 观察者就要继承Observable类。房价一旦发生改变,就应该通过某 种方式通知购房者房价的变更。
观察者模式适用性 适用性: 1.当一个抽象模型有两个方面, 其中一个方面依赖于另一方面。 将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。
2.当对一个对象的改变需要同时改变其它对象, 而不知道具体有 多少对象有待改变。
3.当一个对象必须通知其它对象,而它又不能假定其它对象是 谁。换言之, 你不希望这些对象是紧密耦合的。 4. awt,swing,swt中的监听器对象。
总结
观察者模式(Observer)的优点是实现了抽象与具体的分离,并定 义了稳定的更新消息传递机制,类别清晰,并抽象了更新接口。 观察者模式在被观察者和观察者之间建立一个抽象的耦合。被观察者 角色所知道的只是一个具体现察者聚集,每一个具体现察者都符合一 个抽象观察者的接口。被观察者并不认识任何一个具体观察者,它只 知道它们都有一个共同的接口。由于被观察者和观察者没有紧密地耦 合在一起,因此它们可以属于不同的抽象化层次
观察者模式(Observer Pattern)

观察者模式(Observer Pattern)一、观察者(Observer)模式观察者模式又叫做发布-订阅(Publish/Subscribe)模式、模型-视图(Model/View)模式、源-******(Source/Listener)模式或从属者(Dependents)模式。
观察者模式定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象。
这个主题对象在状态上发生变化时,会通知所有观察者对象,使它们能够自动更新自己。
一个软件系统常常要求在某一个对象的状态发生变化的时候,某些其它的对象做出相应的改变。
做到这一点的设计方案有很多,但是为了使系统能够易于复用,应该选择低耦合度的设计方案。
减少对象之间的耦合有利于系统的复用,但是同时设计师需要使这些低耦合度的对象之间能够维持行动的协调一致,保证高度的协作(Collaboration)。
观察者模式是满足这一要求的各种设计方案中最重要的一种。
二、观察者模式的结构观察者模式的类图如下:可以看出,在这个观察者模式的实现里有下面这些角色:抽象主题(Subject)角色:主题角色把所有对观察考对象的引用保存在一个聚集里,每个主题都可以有任何数量的观察者。
抽象主题提供一个接口,可以增加和删除观察者对象,主题角色又叫做抽象被观察者(Observable)角色,一般用一个抽象类或者一个接口实现。
抽象观察者(Observer)角色:为所有的具体观察者定义一个接口,在得到主题的通知时更新自己。
这个接口叫做更新接口。
抽象观察者角色一般用一个抽象类或者一个接口实现。
在这个示意性的实现中,更新接口只包含一个方法(即Update()方法),这个方法叫做更新方法。
具体主题(ConcreteSubject)角色:将有关状态存入具体现察者对象;在具体主题的内部状态改变时,给所有登记过的观察者发出通知。
具体主题角色又叫做具体被观察者角色(Concrete Observable)。
android observablelist的用法 -回复

android observablelist的用法-回复Android ObservableList 是一个支持观察者模式的列表数据结构。
它可以在数据发生变化时通知注册的观察者并更新界面。
本文将详细介绍ObservableList 的用法,包括其创建、添加、删除、更新数据以及观察者模式的实现。
ObservableList 是Android Support Library 中的一个组件,它可以与RecyclerView、ListView 等列表控件结合使用。
首先,我们需要在build.gradle 文件中添加依赖项:implementation 'androidx.recyclerview:recyclerview:1.2.0' implementation 'androidx.recyclerview:recyclerview-selection:1.1.0'接下来,我们可以在Activity 或Fragment 中创建一个ObservableList,并添加一些数据项:kotlinval itemList: ObservableList<String> = ObservableArrayList<String>().apply {add("Item 1")add("Item 2")add("Item 3")}在上面的代码中,我们创建了一个包含三个字符串的ObservableList。
ObservableArrayList 是ObservableList 的一个具体实现类,它为我们提供了一些常用的方法,比如添加、删除和更新数据。
现在,让我们添加一个观察者来监听数据变化:kotlinval observer = object :ObservableList.OnListChangedCallback<ObservableList<String>>( ) {override fun onChanged(sender: ObservableList<String>?) {当列表数据发生变化时触发这里可以更新界面}override fun onItemRangeChanged(sender: ObservableList<String>?,positionStart: Int,itemCount: Int) {当指定范围内的数据项发生变化时触发这里可以更新对应的列表项}... 其他回调方法}itemList.addOnListChangedCallback(observer)在上面的代码中,我们创建了一个继承自ObservableList.OnListChangedCallback 的观察者,并重写了一些回调方法。
设计模式——观察者模式

2. 定义两个观察者,警察A 警察 B
public class PoliceA implements Observer { /**
* 产生反应 * * @param o 源、即被观察者 * @param arg event事件 */ @Override public void update(Observable o, Object arg) {
} } }
3. 测试
public static void main(String[] args) { BadMan badMan = new BadMan(); badMan.addObserver(new PoliceA()); badMan.addObserver(new PoliceB()); badMan.playAction(); badMan.runAction();
}
3. 定义枚举事件类型
public enum Event { //玩 PLAY(1), //逃跑 RUN(2);
Integer index; /** * 构造 * * @param index */ Event(Integer index) {
this.index = index; }
public Integer getIndex() { return this.index;
public interface Observable {
/** * 注册/添加观察者 * * @param observer 观察者 */ public void addObserver(Observer observer);
/** * 移动观察者 * * @param observer 观察者 */ public void removeObserver(Observer observer);
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
观察者模式_OBSERVER_案例详解1、Observer案例在23种设计模式中,观察者模式算是模式设计中的皇后,尤其是在我们做软件设计过的过程中所体现的更是立足无穷,再说它好,还不如来个实例不是更简单明了,我就把对其概念上的讲解以注释的方式写在代码注释中,如下所示://首先我们需要先定义一个接口为:抽象观察者public interface Watcher{//再定义一个用来获取更新信息接收的方法public void updateNotify(Content content);}//其次定义一个接口为:抽象被观察者public interface Watched{//在其接口中定义一个用来增加观察者的方法public void add(Watcher watcher);//再定义一个用来删除观察者权利的方法public void remove(Watcher watcher);//再定义一个可以实现行为变现并向观察者传输信息的方法public void notifyWatcher(Content content);}//再次就是定义一个类为:具体观察者并实现其接口抽象观察者public class ConcreteWatcher implements Watcher{//并覆盖其方法public void updateNotify(Content content){int id = content.getId();String name = content.getName();String address = content.getAddress();System.out.println("id:"+id++"/n name:"+name+"/n address:"+address); }}//最后就是定义一个类为:具体被观察者并实现其抽象接口抽象被观察者public class ConcreteWatched implements Watched{//定义一个List来封装Watcherprivate List<Watcher> list = new ArrayList<Watcher>();//并覆盖其方法public void add(Watcher watcher){list.add(watcer);}public void remove(Watcher watcher){list.remove(watcher);}public void notifyWatcher(Content content){f or(Watcher watcher : list){watcher.updateWatcher(content);}}}//以面向对象的方式来操作,需要定义一个实体来进行操作public class Content{private int id;private String name;private String address;public void setId(int id){this.id = id;}public int getId(){return id;}public void setName{String name}{ = name;}public String getName(){return name;}public void setAddress(String address){ this.address = address;}public String getAddress(){return address}}//测试类public classs Test{public static void main(String args[]){//实例一个被观察者W atched watched = new Watched();//实例第一个观察者对被观察者进行观察 Watcher watcher1 = new Watcher();//实例第二个观察者对被观察者进行观察Watcher watcher2 = new Watcher();//实例第三个观察者对被观察者进行观察Watcher watcher3 = new Watcher();//加入对其观察watched.add(watcher1);watched.add(watcher2);watched.add(watchre3);//当被观察者发生变化时:调用其信息方法Content content = new Content();content.setId("0001");content.setName("jiangshide");content.setAddress("beijing");watched.notifyWatchers(content);//被观察者可以调用删除方法watched.remove(watchr2);content.setName="litian";watched.notifyWatchers(content);}}好了,以上就是一个完整的对观察者模式设计的核心代码体现,由上面可以知,观察者与被观察者是一个多对一的关系,也就是一个被观察者可同时被多个观察者所共同进行关注,当,被观察者更新时,同时对其观察者会自动更新其信息,为此我又深入的理解并构建了一个UML图:2、核心框架代码:package com.jsd.observer.app;/*** 主抽象被观察者* @author jiangshide**/abstract class MainSubject {abstract void addObserver(MainObserver mainObserver);abstract void removeObserver(MainObserver mainObserver);abstract void notifyObservers(MainContent MainContent);public void localNofity(){}}package com.jsd.observer.app;/*** 主抽象观察者* @author jiangshide**/abstract class MainObserver {abstract void updataNotyfy(MainContent mainContent); public void localNotify(){}}package com.jsd.observer.app;/*** 主内容提供支持* @author jiangshide**/public class MainContent {private int Id;private String name;public int getId() {return Id;}public void setId(int id) {Id = id;}public String getName() {return name;}public void setName(String name) { = name;}}package com.jsd.observer.app;/*** MSN抽象观察者类并继承主抽象观察者* @author jiangshide**/abstract class MsnObserver extends MainObserver { abstract void msnNotify();}package com.jsd.observer.app;/*** MSN抽象被观察者并继承了主抽象被观察者* @author jiangshide**/abstract class MsnSubject extends MainSubject { }package com.jsd.observer.app;/*** Msn内容提供者* @author jiangshide**/public class MsnContent extends MainContent{ private int localId;private String localName;private String msnContent;private String fromResouce;private String fromTime;public int getLocalId() {return localId;}public void setLocalId(int localId) {this.localId = localId;}public String getLocalName() {return localName;}public void setLocalName(String localName) { this.localName = localName;}public String getMsnContent() {return msnContent;}public void setMsnContent(String msnContent) { this.msnContent = msnContent;}public String getFromResouce() {return fromResouce;}public void setFromResouce(String fromResouce) {this.fromResouce = fromResouce;}public String getFromTime() {return fromTime;}public void setFromTime(String fromTime) {this.fromTime = fromTime;}}package com.jsd.observer.app;import java.util.ArrayList;import java.util.List;/*** MSN绝对被观察者类继承了MSN抽象被观察者类* @author jiangshide**/public class MsnConcreteSubject extends MsnSubject {private List<MainObserver> list = new ArrayList<MainObserver>(); MainObserver msnObserver = new MsnConcreteObserver(); MainObserver newsObserver = new NewsConcreteObserver();@Overridevoid addObserver(MainObserver mainObserver) {// TODO Auto-generated method stubif(mainObserver.equals(msnObserver)){//添加关注MSN消息的人list.add(msnObserver);}else if(mainObserver.equals(newsObserver)){//添加关注NEWS新闻的人list.add(newsObserver);}else{//没有想加入任何关注的人}}@Overridevoid notifyObservers(MainContent mainContent) { // TODO Auto-generated method stubfor(MainObserver mainObservers : list){if(mainObservers.equals(msnObserver)){ mainContent = new MsnContent();}}}@Overridevoid removeObserver(MainObserver mainObserver) { // TODO Auto-generated method stubif(mainObserver.equals(msnObserver)){//删除此刻有关注MSN消息的人list.remove(msnObserver);}else if(mainObserver.equals(newsObserver)){//删除此刻有关注NEW新闻的人list.remove(newsObserver);}}}package com.jsd.observer.app;/*** MSN绝对观察者继承了MSN抽象观察者* @author jiangshide**/public class MsnConcreteObserver extends MsnObserver { @Overridepublic void updataNotyfy(MainContent mainContent) {// TODO Auto-generated method stub}@Overridevoid msnNotify() {// TODO Auto-generated method stub}}package com.jsd.observer.app;/*** NEWS抽象观察者并继承了主抽象观察者* @author jiangshide**/abstract class NewsObserver extends MainObserver { }package com.jsd.observer.app;/*** NEWS抽象被观察者继承了主抽象被观察者* @author jiangshide**/abstract class NewsSubject extends MainSubject{}package com.jsd.observer.app;/*** NEWS内容提供者并继承了主内容信息* @author jiangshide**/public class NewsContent extends MainContent{ private int localId;private String localName;private String newsContent;private String fromResource;private String linkWeb;public int getLocalId() {return localId;}public void setLocalId(int localId) {this.localId = localId;}public String getLocalName() {return localName;}public void setLocalName(String localName) {this.localName = localName;}public String getNewsContent() {return newsContent;}public void setNewsContent(String newsContent) { this.newsContent = newsContent;}public String getFromResource() {return fromResource;}public void setFromResource(String fromResource) { this.fromResource = fromResource;}public String getLinkWeb() {return linkWeb;}public void setLinkWeb(String linkWeb) {this.linkWeb = linkWeb;}}package com.jsd.observer.app;/*** NEWS绝对被观察者继承了NEWS抽象被观察者* @author jiangshide**/public class NewsConcreteSubject extends NewsSubject { @Overridevoid addObserver(MainObserver mainObserver) {// TODO Auto-generated method stub}@Overridevoid notifyObservers(MainContent mainContent) {// TODO Auto-generated method stub}@Overridevoid removeObserver(MainObserver mainObserver) {// TODO Auto-generated method stub}}package com.jsd.observer.app;/*** NEWS绝对观察者继承了NEWS抽象观察者* @author jiangshide**/public class NewsConcreteObserver extends NewsObserver {@Overridepublic void updataNotyfy(MainContent mainContent) {// TODO Auto-generated method stub}}好了,上面就是我个人在理解观察者模式后的深入理解,请看代码并能看出结构,希望多提出些介意.....。