Java设计模式-观察者模式
基本概念
观察者模式：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，全部依赖于它的对象都得到通知并被自己主动更新。这样的模式最经常使用在我们熟悉的事件驱动模型里面，像VC、Android界面里面的事件响应，就是基于观察者模式来实现。
观察者模式含义
以下解说一下个人对观察者模式的理解，事实上这个模式在我们平时工作中是非经常常使用的模式，可能你已经使用过，缺没有意识到。
观察者模式主要是针对一对多的数据更新。简单来说就是，系统里面某个元素更新了数据，然后有好几个元素是使用了这个元素的数据。此时更新了数据的对象，就要通知其它使用了它数据的对象，让他们都进行更新。
标准的观察者对象是一对多的关系，只是我们都知道设计模式里面是非常灵活，在我们使用的时候，常常须要进行变形。对现有的标准模式进行适当的改动来适应设计需求。
在我们实际应用中，还会遇到一对一、或者多对一的情况。一对一就是，一个目标相应一个观察者。多对一是指多个目标相应一个观察者。
类图：
实例一
该样例是这种情景：比如：老师有电话号码，学生须要知道老师的电话号码以便于在合适的时候拨打，在这种组合中，老师就是一个被观察者（Subject），学生就是须要知道信息的观察者，当老师的电话号码发生改变时，学生得到通知，并更新对应的电话记录。
Observer.java
/**
* Observer(观察者，Observer)：
* 为那些在目标发生改变时须要获得通知的对象定义一个更新接口。
* @author Andy.Chen
*
*/
public interface Observer{
public void update();
}
Subject.java
/**
* Subject(目标，Subject)： 是我们定义目标对象，或者说被观察对象。
* 目标知道它的观察者。能够有随意多个观察者观察同一个目标。
* 提供注冊和删除观察者对象的接口。
* @author Andy.Chen
*
*/
public interface Subject {
public void attach(Observer mObserver);
public void detach(Observer mObserver);
public void notice();
}
Teacher.java
import java.util.Vector;
/**
* ConcreteSubject(详细目标，Teacher)是实际的被观察对象
* 将有关状态存入各ConcreteObserve对象。
* 当他的状态发生改变时，向他的各个观察者发出通知。
* @author Andy.Chen
*
*/
public class Teacher implements Subject{
private String phone;
private Vector students;
public Teacher(){
phone = "";
students = new Vector();
}
@Override
public void attach(Observer mObserver) {
students.add(mObserver);
}
@Override
public void detach(Observer mObserver) {
students.remove(mObserver);
}
@Override
public void notice() {
for(int i=0;i<students.size();i++){
((Observer)students.get(i)).update();
}
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
notice();
}
}
观察者对象
Student.java
/**
* ConcreteObserver(详细观察者, Student)：是实际的观察者对象。
* 维护一个指向ConcreteSubject对象的引用。
* 存储有关状态，这些状态应与目标的状态保持一致。
* 实现Observer的更新接口以使自身状态与目标的状态保持一致。
* @author Andy.Chen
*
*/
public class Student implements Observer{
private String name;
private String phone;
private Teacher mTeacher;
public Student(String name,Teachert){
this.name = name;
mTeacher = t;
}
public void show(){
System.out.println("Name:"+name+"\nTeacher'sphone:" + phone);
}
@Override
public void update() {
phone = mTeacher.getPhone();
}
}
測试类
Test.java
import java.util.Vector;
public class Test {
public static void main(String[] args) {
Vectorstudents = new Vector();
Teacher t = new Teacher();
for(int i= 0;i<10;i++){
Student st = new Student("Andy.Chen"+i,t);
students.add(st);
t.attach(st);
}
System.out.println("Welcome to Andy.Chen Blog!" +"\n"
+"Observer Patterns." +"\n"
+"-------------------------------");
t.setPhone("12345678");
for(inti=0;i<3;i++)
((Student)students.get(i)).show();
t.setPhone("87654321");
for(inti=0;i<3;i++)
((Student)students.get(i)).show();
}
}
实例二
Android中View的点击事件
OnClickListener.java
public interface OnClickListener {
void onClick(TextView v);
}
TextView.java
public class TextView{
OnClickListener l;
public TextView(){
}
//模拟点击
public void click(){
l.onClick(this);
}
public void setOnClickListener(OnClickListener l){
this.l = l;
}
}
Test.java
public class Test {
public static void main(String[] args) {
TextView tv = new TextView();
tv.setOnClickListener(new OnClickListener() {
@Override
public void onClick(TextView v) {
System.out.println(v.getClass().getName()+"点击了");
}
});
tv.click();
}
}
总结：观察者模式何时适用？
1.当一个抽象模型有两个方面，当中一个方面依赖于还有一方面。将这二者封装在独立的对象中能够使他们各自独立地改变和复用。
2.当对一个对象的改变须要同一时候改变其他对象，而不知道详细由多少对象有待改变。
3.当一个对象必须通知其它对象，而它又不能假定其它对象是谁，换言之，你不希望这些对象是紧密耦合的。让耦合的两方都依赖于抽象，而不是依赖于详细。
