Android Observer观察者模式

Android Observer观察者模式，就是java那一套观察者模式。今天就来介绍下这个模式的使用方法，其实在Android中很多内容都用到了这个模式，比如说BaseAdapter AbsListView View等都有，只是名字各有不同。
  首先 我们先要知道，观察者模式中主要有观察者和被观察者2个对象，而在观察模式中Observable表示被观察者，由于这个对象是一个抽象类只能被继承。而Observer表示观察者，它并不是一个类而是一个接口，所以观察者可以有多个，实现了该接口的类都属于观察者。 当然有人会问既然被观察者是一个抽象类而观察者是一个接口，那么是否有一个类即继承Observable类又实现Observer接口呢，这个自然可以，观察者当然也可以同时是被观察者，被观察者同样可以是观察者，在这里完全不冲突。
  被观察者（Observable）与观察者（Observer）
     当某一个我们需要被观察的对象继承自Observable类时，就表示该类可以被很多观察者（实现了Observer）观察，其实意思就是说这个对象也就是被观察者“上电视了”，电视前的你也就是观察者可以看，（对象发生变化）电视里被观察者做了别的动作，那么电视前的所有人看到的也就变了，在同一时间改变所有观众看到的画面。
   那么现在有了几个问题：
  问题一：既然继承自Observable的类都是被观察者（相当于一个电视频道），而实现了Observer的都是观察者（电视前的观众），那“电视台”怎么知道有哪些“观众”在看它这个台呢，也就是这个被观察者被多少个观察者观察着呢？
  问题二：虽然电视机可以直接通过不断的发送信号来改变观众面前电视机的画面，可是代码是怎么实现观察者观察的被观察者发生了变化了让自己得到的数据也跟着变化的呢？

例如：MyPerson是被观察者：
[mw_shl_code=java,true]public class MyPerson extends Observable {

        private int age;
        private String name;
        private String sax;
       
        public int getAge() {
                return age;
        }

        public void setAge(int age) {
                this.age = age;
                setChanged();
                notifyObservers();
        }

        public String getName() {
                return name;
        }

        public void setName(String name) {
                this.name = name;
                setChanged();
                notifyObservers();
        }

        public String getSax() {
                return sax;
        }

        public void setSax(String sax) {
                this.sax = sax;
        }

        @Override
        public String toString() {
                return "MyPerson [age=" + age + ", name=" + name + ", sax=" + sax + "]";
        }
}[/mw_shl_code]

注意到：setChanged();notifyObservers();多了这两句调用，而这里就是解决问题二所在，它通过setChanged();告知数据改变，通过notifyObservers();发送信号通知观察者。

MyObserver是观察者：
[mw_shl_code=java,true]public class MyObserver implements Observer {
       
        private int i;
        private MyPerson myPerson;//观察的对象
       
        public MyObserver(int i){
                System.out.println("我是观察者---->" + i);
                this.i = i;
        }

        public int getI() {
                return i;
        }

        public void setI(int i) {
                this.i = i;
        }

        public MyPerson getMyPerson() {
                return myPerson;
        }

        public void setMyPerson(MyPerson myPerson) {
                this.myPerson = myPerson;
        }

        @Override
        public void update(Observable observable, Object data) {
                System.out.println("观察者---->"+ i +"得到更新！");
                this.myPerson = (MyPerson)observable;
                System.out.println(((MyPerson)observable).toString());
        }

}[/mw_shl_code]

这里我们看到，实现了Observer，只有一个update方法，那么这个方法什么时候被调用呢，很显然，在上面我们有通知的信号，那么这里就是接受到信号后执行的动作。

MainActivity主函数：
[mw_shl_code=java,true]public class MainActivity extends ListActivity {

        private Button add;
        private MyPerson observable;
        private int i = 1;
        private Button change;
        private ListView lv;
        private List<MyObserver> myObservers;
       
        private Handler handler = new Handler(new Handler.Callback() {
               
                @Override
                public boolean handleMessage(Message msg) {
                        // 将信息加入list中显示
                        MyListAdapter myListAdapter = new MyListAdapter(MainActivity.this, myObservers);
                        lv.setAdapter(myListAdapter);
                        return false;
                }
        });

        @Override
        public void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                setContentView(R.layout.activity_main);
                add = (Button) findViewById(R.id.add);
                observable = new MyPerson();
                myObservers = new ArrayList<MyObserver>();
                lv = getListView();
                //添加观察者
                add.setOnClickListener(new View.OnClickListener() {

                        @Override
                        public void onClick(View v) {
                                MyObserver myObserver = new MyObserver(i);
                                i++;
                                observable.addObserver(myObserver);
                                myObservers.add(myObserver);
                                handler.sendEmptyMessage(0);
                        }
                });
                change = (Button) findViewById(R.id.change);
                //通知数据改变
                change.setOnClickListener(new View.OnClickListener() {

                        @Override
                        public void onClick(View v) {
                                observable.setAge(10 + i);
                                observable.setName("a" + i);
                                observable.setSax("男" + i);
                                handler.sendEmptyMessage(0);
                        }
                });
        }

        @Override
        public boolean onCreateOptionsMenu(Menu menu) {
                getMenuInflater().inflate(R.menu.activity_main, menu);
                return true;
        }

}[/mw_shl_code]

add这个button是用来添加观察者的，而我们看到myObservers.add(myObserver);这样一句，那么这里就是解决问题一所在了，它的意思就是为被观察者添加观察者的。change这个button用来改变数据用于测试。

最后，看戏实例的效果图：
当第一次点击（点击5次增加5个）“添加观察者”：     第一次点击“改变数据”：
                                                                        
当第二次点击（点击2次增加2个）“添加观察者”： 第二次点击“添加观察者”：

                                                                        

转载：http://www.apkbus.com/android-112815-1-1.html

值得注意的是在android中mms的发送和接收，用到的就是观察者模式。其中Transaction继承了Observable，而Transaction的真正实现是SendTransaction。TransactionService实现了Observer.