设计模式---观察者模式

1.定义：关于多个对象想知道一个对象中数据变化情况的一种成熟模式。

2.GOF引用：定义对象间的一种一对多的依赖关系，当一个对象的状态发生变化时，所有依赖它的对象都得到通知并被更新。

3.理解：

模式中有一个“主题”对象和若干个“观察者”对象。两者之间是一对多的依赖关系。

结构包括四种角色。先以类图展现。

4.类图：

主题：主题是一个接口，该接口规定具体主体需要实现的方法，比如：添加、删除观察者以及通知观察者更新数据的方法。

观察者：观察者是一个借口，该接口规定了具体观察者用来更新数据的方法。

具体主题：实现主题接口，是主题接口的一个实例。包含可以经常发生变化的数据。具体主题使用一个集合，比如ArrayList，存放观察者的引用，以便数据变化时通知具体观察者。

具体观察者：是观察者接口类的一个实例。包含有存放具体主题引用的主题接口变量，以便通知具体主题添加或者删除自身（观察者）。

5. 观察者模式举例（代码示例）

问题描述如下：有一个大学毕业生和一个归国留学生都希望及时知道“求职中心”最新的职业需求信息。

类图：

具体代码如下：

package cn.ch;
public abstract interface Subject {

	public abstract void addObserver(Observer o);

	public abstract void deleteObserver(Observer o);

	public abstract void notifyObservers();

}
package cn.ch;
public abstract interface Observer {

	public abstract void hearTelephone(String hearMess);

}
package cn.ch;

import java.util.ArrayList;

public class SeekJobCenter implements Subject {
	String mess;
	boolean changed;
	private ArrayList<Observer> personList; // 存放观察者引用的数组线性表

	public SeekJobCenter() {
		super();
		personList = new ArrayList<Observer>();
		mess = "";
	}

	public void addObserver(Observer o) {
		if (!(personList.contains(o)))
			personList.add(o);           //把观察者的引用添加到数组线性表
	}

	public void deleteObserver(Observer o) {
		if(personList.contains(o))
			personList.remove(o);
	}

	public void notifyObservers() {
		if(changed){                     //通知所有的观察者
			for(int i=0;i<personList.size();i++){
				Observer observer = personList.get(i);
				observer.hearTelephone(mess);        //让观察着接听电话
			}
			changed=false;
		}
	}

	public void giveNewMess(String str) {
		if(str.equals(mess))
			changed=false;
		else{
			mess=str;
			changed=true;
		}
	}

}
package cn.ch;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;

public class UniversityStudent implements Observer {

	private Subject subject;
	File myFile;

	public UniversityStudent(Subject subject, String fileName) {
		super();
		this.subject = subject;
		subject.addObserver(this); // 使当前实例成为subject所引用的具体主题的观察者
		this.myFile = new File(fileName);
	}

	public void hearTelephone(String heardMess) {
		try {
			RandomAccessFile out = new RandomAccessFile(myFile, "rw");
			out.seek(out.length());
			byte[] b = heardMess.getBytes();
			out.write(b); // 更新文件中的内容
			System.out.print("我是一个大学生，");
			System.out.println("我向文件" + myFile.getName() + "写入如下内容：");
			System.out.println(heardMess);
		} catch (IOException e) {
			e.printStackTrace();
		}

	}
}
package cn.ch;

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;

public class HaiGui implements Observer {
	private Subject subject;
	File myFile;
	public HaiGui(Subject subject,String fileName) {
		super();
		this.subject = subject;
		subject.addObserver(this);   //使当前实例成为subject所引用的具体主题的观察者
		this.myFile = new File(fileName);
	}

	public void hearTelephone(String heardMess) {
		try{boolean boo=heardMess.contains("java程序员")||heardMess.contains("软件");
		if(boo){
			RandomAccessFile out=new RandomAccessFile(myFile, "rw");
			out.seek(out.length());
			byte[] b=heardMess.getBytes();
			out.write(b);
			System.out.print("我是一个海归，");
			System.out.println("我向文件"+myFile+"写入如下内容：");
			System.out.println(heardMess);
		}
		else
			System.out.println("我是海归，这次的信息中没有我需要的信息");
			
		}catch (IOException e) {
			System.out.println(e.toString());
		}
	}


	

}
package cn.ch;
public class Application{
	public static void main(String[] args) {
		SeekJobCenter center=new SeekJobCenter();     //具体主题center
		UniversityStudent zhangLin=new UniversityStudent(center, "A.txt"); //具体观察者zhangLin
		HaiGui wangHao=new HaiGui(center, "B.txt"); //具体观察者wangHao
		center.giveNewMess("腾辉公司需要10个java程序员。");    //具体主题给出新信息
		center.notifyObservers();       //具体主题通知信息
		center.giveNewMess("海景公司需要8个动画设计师。");    
		center.notifyObservers();    
		center.giveNewMess("仁海公司需要9个电工。");    
		center.notifyObservers();    
		center.giveNewMess("仁海公司需要9个电工。");    //信息不是新的 
		center.notifyObservers();                 //观察者不会执行更新操作
	}
}

观察者模式的优点：

1. 具体主题和具体观察者是松耦合的关系。

2. 观察者模式满足“开闭原则”。

适合使用观察者模式的情景：

1. 当一个对象的数据更新是需要通知其他对象，但这个对象又不希望和被通知的那些对象形成紧耦合。

2. 当一个对象的数据更新时这个对象需要让其他对象也各自更新自己的数据，但这个对象不知道具体有多少对象需要更新数据。