基本概念
观察者模式：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式最常用在我们熟悉的事件驱动模型里面，像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.当一个对象必须通知其他对象，而它又不能假定其他对象是谁，换言之，你不希望这些对象是紧密耦合的。让耦合的双方都依赖于抽象，而不是依赖于具体。