Observer观察者模式

首先 我们先要知道，观察者模式中主要有观察者和被观察者2个对象，而在观察模式中Observable表示被观察者，由于这个对象是一个抽象类只能被继承。而Observer表示观察者，它并不是一个类而是一个接口，所以观察者可以有多个，实现了该接口的类都属于观察者。

当然有人会问既然被观察者是一个抽象类而观察者是一个接口，那么是否有一个类即继承Observable类又实现Observer接口呢，这个自然可以，观察者当然也可以同时是被观察者，被观察者同样可以是观察者，在这里完全不冲突。

被观察者（Observable）与观察者（Observer）
     当某一个我们需要被观察的对象继承自Observable类时，就表示该类可以被很多观察者（实现了Observer）观察，其实意思就是说这个对象也就是被观察者“上电视了”，电视前的你也就是观察者可以看，（对象发生变化）电视里被观察者做了别的动作，那么电视前的所有人看到的也就变了，在同一时间改变所有观众看到的画面。

实例:
1,新建MyPerson继承自Observable,表示该类为 "被观察者"
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 + "]";
    }
}

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

2,MyObserver是观察者：
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
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) { //如果被观察者 数据发生了改变,这回进入这update中
        System.out.println("观察者---->"+ i +"得到更新！");
        this.myPerson = (MyPerson)observable;
        System.out.println(((MyPerson)observable).toString());
    }
 
}

 
 这里我们看到，实现了Observer，只有一个update方法，那么这个方法什么时候被调用呢，很显然，在上面我们有通知的信号，那么这里就是接受到信号后执行的动作。
 
3,MainActivity
  1. package com.example.mobservermode;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import android.app.Activity;
  6. import android.os.Bundle;
  7. import android.os.Handler;
  8. import android.os.Message;
  9. import android.view.View;
  10. import android.view.View.OnClickListener;
  11. import android.view.ViewGroup;
  12. import android.widget.BaseAdapter;
  13. import android.widget.Button;
  14. import android.widget.ListView;
  15. import android.widget.TextView;
  17. public class MainActivity extends Activity {
  19. 	private Button btn_add;
  20. 	private Button btn_update;
  21. 	private ListView lv;
  22. 	
  23. 	private int i = 1;
  24. 	//观察者集合
  25. 	private List<MyObserver> list=new ArrayList<MyObserver>();
  26. 	//被观察者
  27. 	private MyPerson observable;
  28. 	
  29. 	private Handler handler = new Handler(new Handler.Callback() {
  30. 		
  31. 		@Override
  32. 		public boolean handleMessage(Message msg) {
  33. 			// 将信息加入list中显示
  34. 			MyAdapter myListAdapter = new MyAdapter();
  35. 			lv.setAdapter(myListAdapter);
  36. 			return false;
  37. 		}
  38. 	});
  39. 	
  40. 	@Override
  41. 	protected void onCreate(Bundle savedInstanceState) {
  42. 		super.onCreate(savedInstanceState);
  43. 		setContentView(R.layout.activity_main);
  44. 		
  45. 		observable = new MyPerson();
  46. 		
  47. 		lv=(ListView) findViewById(R.id.lv);
  48. 		btn_add=(Button) findViewById(R.id.btn_add);
  49. 		btn_update=(Button) findViewById(R.id.btn_update);
  50. 		btn_add.setOnClickListener(new OnClickListener() {
  51. 			@Override
  52. 			public void onClick(View v) {
  53. 				MyObserver myObserver = new MyObserver(i);
  54. 				i++;
  55. 				observable.addObserver(myObserver);
  56. 				list.add(myObserver);
  57. 				handler.sendEmptyMessage(0);
  58. 			}
  59. 		});
  60. 		btn_update.setOnClickListener(new OnClickListener() {
  61. 			
  62. 			@Override
  63. 			public void onClick(View v) {
  64. 				observable.setAge(10 + i);
  65. 				observable.setName("a" + i);
  66. 				observable.setSex("男" + i);
  67. 				handler.sendEmptyMessage(0);
  68. 			}
  69. 		});
  70. 		
  71. 	}
  72. 	private class MyAdapter extends BaseAdapter{
  74. 		@Override
  75. 		public int getCount() {
  76. 			return list.size();
  77. 		}
  79. 		@Override
  80. 		public Object getItem(int position) {
  81. 			return list.get(position);
  82. 		}
  84. 		@Override
  85. 		public long getItemId(int position) {
  86. 			return position;
  87. 		}
  89. 		@Override
  90. 		public View getView(int position, View convertView, ViewGroup parent) {
  91. 			TextView tv = new TextView(MainActivity.this);
  92. 			tv.setTextSize(15);
  93. 			String personContent = "内容还没添加";
  94. 			if (list.get(position).getMyPerson() != null) {
  95. 				personContent = list.get(position).getMyPerson().toString();
  96. 			}
  97. 			tv.setText("观察者ID：------>" + list.get(position).getI() + "\n"
  98. 					+ "观察内容：" + personContent);
  99. 			return tv;
  100. 		}
  101. 		
  102. 	}
  103. 	
  104. 	
  106. }









附件列表

     

    posted @ 2014-12-08 17:05  冷冷汤圆  阅读(270)  评论(0)    收藏  举报