android觀察者
『壹』 android 觀察者模式 我被觀察的信息在activity中 但是他要繼承Observable，但是他要繼承Activity的阿 這
兩個解決辦法，
1、多謝一個類，作為中間類，這個類，繼承Observable，然後，讓這個類，再繼承Activity。我沒試過這種方式。
2、這種方式肯定可行，就是自己構建一個觀察者模式。如果你對觀察者模式很了解。這個很容易。
『貳』 android設計模式中的觀察者模式能說一下嗎
java">/*
*觀察者模式
*定義對象間的一種一個(Subject)對多(Observer)的依賴關系，當一個對象的狀態發送改變時，所以依賴於它的
*對象都得到通知並被自動更新
*
*當然，MVC只是Observer模式的一個實例。Observer模式要解決的問題為：
*建立一個一（Subject）對多（Observer）的依賴關系，並且做到當「一」變化的時候，
*依賴這個「一」的多也能夠同步改變。最常見的一個例子就是：對同一組數據進行統計分析時候，
*我們希望能夠提供多種形式的表示（例如以表格進行統計顯示、柱狀圖統計顯示、百分比統計顯示等）。
*這些表示都依賴於同一組數據，我們當然需要當數據改變的時候，所有的統計的顯示都能夠同時改變。
*Observer模式就是解決了這一個問題。
*
*適用性：
*1.當一個抽象模型有兩個方面，其中一個方面依賴於另一方面
*將這兩者封裝成獨立的對象中以使它們可以各自獨立的改變和服用
*
*2.當對一個對象的改變需要同時改變其他對象，而不知道具體有多少對象有待改變
*
*3.當一個對象必須通知其它對象，而它又不能假定其它對象是誰
*
*參與者：
*1.Subject（目標）
*目標知道它的觀察者，可以有任意多個觀察者觀察同一個目標
*提供注冊和刪除觀察者對象的介面
*
*2.Observer（觀察者）
*為那些在目標發生改變時需獲得通知的對象定義個更新的介面
*
*3.ConcreteSubject（具體目標）
*將有關狀態存入各ConcreteObserver對象
*當它的狀態發送改變時，向它的各個觀察者發出通知
*
*4.ConcreteObserver（具體觀察者）
*維護一個指向ConcreteObserver對象的引用
*存儲有關狀態，這些狀態應與目標的狀態保持一致
*實現Observer的更新介面是自身狀態與目標的狀態保持一致
*
*
**/
『叄』 Android中有沒有對多個對象的監聽方法，就像觀察者模式一樣
Android
中的監聽器模式與觀察者模式
1、 觀察者模式與監聽器機制
1.1 觀察者模式
1.2 監聽器（Listener）機制
代碼的基本框架：
* 被監控著
package com.wonders.group;
import java.util.Collection;
public class ModelTie {
private Collection<Object> dataSet;
public interface DataSetSupervioer {
public void onChange();
}
private DataSetSupervioer dataSetChangeListener;
public void setDataSetChangeListener(DataSetSupervioer
dataSetChangeListener) {
this.dataSetChangeListener = dataSetChangeListener;
}
public void notifyDataSetChange() {
if (null != dataSetChangeListener) {
dataSetChangeListener.onChange();
}
}
public Collection<Object> getDataSet() {
return dataSet;
}
public ModelTie setDataSet(Collection<Object> dataSet)
{
this.dataSet = dataSet;
this.notifyDataSetChange(); // 數據設置完畢要通知監聽器進行更新操作
return this;
}
}
* 監控者
package com.wonders.group;
import java.util.Collection;
import java.util.Iterator;
import com.wonders.group.ModelTie.DataSetSupervioer;
public class PresentationTie {
private ModelTie model;
public PresentationTie() {
super();
// 添加監聽器
model.setDataSetChangeListener(new DataSetSupervioer()
{
public void onChange() {
// 填寫一些前置操作，如更新數據
DisplayModel(); // 重新繪制
// 填寫一些後置操作，如更新狀態
}
});
}
public void DisplayModel() {
Collection<Object> collection =
model.getDataSet();
if (collection != null) {
for (Iterator iterator = collection.iterator();
iterator.hasNext();) {
System.out.println(((Object)
iterator.next()).toString());
// 其他等等操作
}
}
}
public ModelTie getModel() {
return model;
}
public void setModel(ModelTie model) {
this.model = model;
}
}
2、
ArrayAdapter的觀察者實現機制
以下僅羅列關鍵代碼：
public class ArrayAdapter<T> extends BaseAdapter implements Filterable
{
private boolean mNotifyOnChange = true;
/**
* Adds the specified object at the end of the array.
*/
public void add(T object) {
if (mOriginalValues != null) {
synchronized (mLock) {
mOriginalValues.add(object);
if (mNotifyOnChange) notifyDataSetChanged();
}
} else {
mObjects.add(object);
if (mNotifyOnChange) notifyDataSetChanged();
}
}
/**
* Inserts the specified object at the specified index in the
array.
*/
public void insert(T object, int index) {
if (mOriginalValues != null) {
synchronized (mLock) {
mOriginalValues.add(index, object);
if (mNotifyOnChange) notifyDataSetChanged();
}
} else {
mObjects.add(index, object);
if (mNotifyOnChange) notifyDataSetChanged();
}
}
/**
* Removes the specified object from the array.
*/
public void remove(T object) {
if (mOriginalValues != null) {
synchronized (mLock) {
mOriginalValues.remove(object);
}
} else {
mObjects.remove(object);
}
if (mNotifyOnChange) notifyDataSetChanged();
}
/**
* Remove all elements from the list.
*/
public void clear() {
if (mOriginalValues != null) {
synchronized (mLock) {
mOriginalValues.clear();
}
} else {
mObjects.clear();
}
if (mNotifyOnChange) notifyDataSetChanged();
}
/**
* Sorts the content of this adapter using the specified
comparator.
*/
public void sort(Comparator<? super T> comparator) {
Collections.sort(mObjects, comparator);
if (mNotifyOnChange) notifyDataSetChanged();
}
@Override
public void notifyDataSetChanged() {
super.notifyDataSetChanged(); //
關鍵代碼，這個notifyDataSetChanged()是從父類BaseAdapter繼承過來的，所以看看在父類中它幹了些什麼
mNotifyOnChange = true;
}
}
/**
* Common base class of common implementation for an {@link
Adapter} that can be
* used in both {@link ListView} (by implementing the
specialized
* {@link ListAdapter} interface} and {@link Spinner} (by
implementing the
* specialized {@link SpinnerAdapter} interface.
*/
public abstract class BaseAdapter implements ListAdapter,
SpinnerAdapter {
private final DataSetObservable mDataSetObservable = new
DataSetObservable();
public void registerDataSetObserver(DataSetObserver observer)
{
這對方法用來注冊或注銷
觀察ArrayAdapter的觀察者的
mDataSetObservable.registerObserver(observer);
}
public void unregisterDataSetObserver(DataSetObserver
observer) {
mDataSetObservable.unregisterObserver(observer);
}
/**
* Notifies the attached View that the underlying data has
been changed
* and it should refresh itself.
*/
public void notifyDataSetChanged() {
mDataSetObservable.notifyChanged(); //
關鍵代碼：說明調的是成員變數mDataSetObservable的方法，所以進入DataSetObservable看看具體是如何操作的
}
public void notifyDataSetInvalidated() {
mDataSetObservable.notifyInvalidated();
}
}
package android.database;
/**
* A specialization of Observable for DataSetObserver that
provides methods for
* invoking the various callback methods of DataSetObserver.
*/
public class DataSetObservable extends
Observable<DataSetObserver> {
/**
* Invokes onChanged on each observer. Called when the data
set being observed has
* changed, and which when read contains the new state of the
data.
*/
public void notifyChanged() {
synchronized(mObservers) {
for (DataSetObserver observer : mObservers) { //
這里的mObservers是哪來的呢?繼續追蹤，但首先可以判斷是來自Observable<DataSetObserver>的。進入看看
observer.onChanged();
}
}
}
/**
* Invokes onInvalidated on each observer. Called when the
data set being monitored
* has changed such that it is no longer valid.
*/
public void notifyInvalidated() {
synchronized (mObservers) {
for (DataSetObserver observer : mObservers) {
observer.onInvalidated();
}
}
}
}
public abstract class Observable<T> {
/**
* The list of observers. An observer can be in the list at
most
* once and will never be null.
*/
protected final ArrayList<T> mObservers = new
ArrayList<T>();
public void registerObserver(T observer) {
if (observer == null) {
throw new IllegalArgumentException("The observer is
null.");
}
synchronized(mObservers) {
if (mObservers.contains(observer)) {
throw new IllegalStateException("Observer " +
observer + " is already registered.");
}
mObservers.add(observer);
}
}
public void unregisterObserver(T observer) {
if (observer == null) {
throw new IllegalArgumentException("The observer is
null.");
}
synchronized(mObservers) {
int index = mObservers.indexOf(observer);
if (index == -1) {
throw new IllegalStateException("Observer " +
observer + " was not registered.");
}
mObservers.remove(index);
}
}
public void unregisterAll() {
synchronized(mObservers) {
mObservers.clear();
}
}
}
『肆』 觀察者模式 在android中什麼時候會用到
android中注冊簡訊和聯系人的變更,就會用到觀察者模式
通過ContentProvider注冊一個observer實現的
『伍』 android eventbus 底層是什麼實現的
參考csdn的博客：
尊重原創：http://blog.csdn.net/yuanzeyao/article/details/38174537
代碼下載：http://download.csdn.net/detail/yuanzeyao2008/7684041
在編程過程中，當我們想通知其他組件某些事情發生時，我們通常使用觀察者模式，正式因為觀察者模式非常常見，所以在jdk1.5中已經幫助我們實現了觀察者模式，我們只需要簡單的繼承一些類就可以快速使用觀察者模式，在Android中也有一個類似功能的開源庫EventBus，可以很方便的幫助我們實現觀察者模式，那麼我們就開始學習如何使用EventBus.
在接下來的內容中，我首先會介紹如何使用EventBus,然後再簡單的學習一下EventBus的底層實現原理，因為僅僅學習如何使用總是感覺內心不夠踏實，萬一哪天出了Bug也無從下手，了解了它的基本實現後，就會用得游刃有餘。好了 廢話不多說，下面開始學習吧
1、下載EventBus庫：
EvnetBus的下載地址：https://github.com/greenrobot/EventBus.git
2、將EventBus.jar放入自己工程的libs目錄即可
3、定義一個事件，這個事件一旦被EventBus分發出去就是代表某一件事情發生了，這個事件就是某個觀察者關心的事情(不需要繼承任何類)
4、定義觀察者，然後將該觀察者注冊到EventBus
5、由EventBus分發事件，告知觀察者某一件事情發生了
6、使用完成後從EventBus中反注冊觀察者。
熟悉觀察者模式的朋友肯定對於上面的流程非常熟悉，其實和觀察模式基本是一樣的。但是也是有區別的。在觀察者模式中，所有的觀察者都需要實現一個介面，這個介面有一個統一的方法如:
public void onUpdate()；
然後當某一個事件發生時，某個對象會調用觀察者的onUpdate方法通知觀察者某件事情發生了，但是在EventBus中不需要這樣，EventBus中是這樣實現的：
在EventBus中的觀察者通常有四種訂閱函數（就是某件事情發生被調用的方法）
1、onEvent
2、onEventMainThread
3、onEventBackground
4、onEventAsync
這四種訂閱函數都是使用onEvent開頭的，它們的功能稍有不同,在介紹不同之前先介紹兩個概念：
告知觀察者事件發生時通過EventBus.post函數實現，這個過程叫做事件的發布，觀察者被告知事件發生叫做事件的接收，是通過下面的訂閱函數實現的。
『陸』 android內容觀察者有哪些
攔截簡訊，比如當發簡訊的時候，就把簡訊讀取出來，當系統的簡訊發生變化的時候，大叫一聲，把數據發送到公共的消息郵箱裡面，我們的應用通過內容觀察者觀察公共的消息郵箱
獲取ContentResolver對象，調用函數getContentResolver()，
調用ContentResolver對象的
registerContentObserver(uri,notifyForDescendents,observer)方法，參數：Uri對象，是否
精確uri（true不精確，false精確），observer對象 ContentObserver對象
因為ContentObserver是抽象類，因此我們寫一個內部類來繼承這個抽象類，必須實現構造函數，構造函數的Handler對象消息處理器
稍後會講，定義一個內部類MyObserver，實現父類的onChange()回調方法，觀察到消息郵箱發生變化的時候會回調這個方法。
在這個回調函數裡面，使用獲取到簡訊內容，取最後一條，調用Cursor對象的moveToFirst()指針指向最後一條
系統應用是如何發出這個叫聲的呢，獲取ContentResolver對象，通過getContentResolver()方法，調用
ContentResolver對象的notifyChange(uri,observer)方法，參數：uri隨便定義，observer指定誰處理默
認null
系統的很多應用進行通知通信都是通過這個公共消息郵箱機制來實現的
接下來實戰一下，接著《Android 內容提供者的實現》中使用的項目作為基礎，新建一個項目，並添加代碼如下：
package com.wuyudong.observer;
import android.net.Uri;
import android.os.Bundle;
import android.os.Handler;
import android.app.Activity;
import android.content.ContentResolver;
import android.content.Context;
import android.database.ContentObserver;
import android.view.Menu;
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Uri uri = Uri.parse("content://com.wuyudong.db.personprovider/");
getContentResolver().registerContentObserver(uri, true,
new MyObserver(new Handler()));
}
private class MyObserver extends ContentObserver {
public MyObserver(Handler handler) { // handler 是一個消息處理器
super(handler);
}
@Override
public void onChange(boolean selfChange) {
// TODO Auto-generated method stub
System.out.println("haha,資料庫的內容變化了！！！");
super.onChange(selfChange);
}
}
}
並修改PersonDBProvider.java中的代碼：
public Uri insert(Uri uri, ContentValues values) {
if (matcher.match(uri) == INSERT) {
// 返回查詢的結果集
SQLiteDatabase db = helper.getWritableDatabase();
db.insert("person", null, values);
getContext().getContentResolver().notifyChange(uri, null);
} else {
throw new IllegalArgumentException("路徑不匹配，不能執行插入操作");
}
return null;
}
@Override
public int delete(Uri uri, String selection, String[] selectionArgs) {
if (matcher.match(uri) == DELETE) {
// 返回查詢的結果集
SQLiteDatabase db = helper.getWritableDatabase();
int result = db.delete("person", selection, selectionArgs);
db.close();
if (result > 0) {
getContext().getContentResolver().notifyChange(uri, null);
}
} else {
throw new IllegalArgumentException("路徑不匹配，不能執行刪除操作");
}
return 0;
}
這樣在每次點擊按鈕的時候，都會列印相關資料庫數據被修改的提示
『柒』 內容觀察者可以刪除簡訊么android
//刪除簡訊（單條）
public void delSMS(String id){
getContentResolver().delete(Uri.parse("content://sms"),
"_id=" + id, null);
Log.i(TAG, "刪除簡訊_id = " + id );
}
『捌』 android源碼里哪些地方用到了觀察者模式
1. Subject被觀察者。是一個介面或者是抽象類，定義被觀察者必須實現的職責，它必須能偶動態地增加、取消觀察者，管理觀察者並通知觀察者。
2. Observer觀察者。觀察者接收到消息後，即進行update更新操作，對接收到的信息進行處理。
3. ConcreteSubject具體的被觀察者。定義被觀察者自己的業務邏輯，同時定義對哪些事件進行通知。
4. ConcreteObserver具體觀察者。每個觀察者在接收到信息後處理的方式不同，各個觀察者有自己的處理邏輯。
觀察者模式有什麼優點呢：
觀察者和被觀察者之間是抽象耦合的，不管是增加觀察者還是被觀察者都非常容易擴展。
根據單一職責原則，每個類的職責是單一的，那麼怎麼把各個單一的職責串聯成真實的復雜的邏輯關系呢，觀察者模式可以起到橋梁作用。
觀察者模式是松耦合的典型。
在Android源碼中，其中一個經典的使用到觀察者模式的就是Android控制項的事件監聽模型。
『玖』 android中觀察者模式的應用場景是什麼
你說的場景是符合這個模式的：
觀察者模式的應用場景：
1、 對一個對象狀態的更新，需要其他對象同步更新，而且其他對象的數量動態可變。
2、 對象僅需要將自己的更新通知給其他對象而不需要知道其他對象的細節。
觀察者模式的優點：
1、 Subject和Observer之間是松偶合的，分別可以各自獨立改變。
2、 Subject在發送廣播通知的時候，無須指定具體的Observer，Observer可以自己決定是否要訂閱Subject的通知。
3、 遵守大部分GRASP原則和常用設計原則，高內聚、低偶合。