二十三种设计模式——观察者模式

二十三种设计模式总述

---

当对象间存在依赖关系时，使用观察者模式进行通知其依赖项。比如：C++中的虚函数的实现。当子类重写了虚函数的时候，其虚函数表中该虚函数的的地址就会改变。但是，这不是典型的观察者模式，因为编译器知道地址的改变，但是父类并不知道。实际上，应该是父类的对象发生改变，子类的观察者也会被通知到，这就是观察者模式。

举个生活中的例子。老师给学生上课，学生去上课，老师就是被观察者，老师讲的知识一改变，学生就会收到信息，并给出相应操作。那么代码是怎么实现的？

我们就利用老师授课，学生上课的例子：

/*
 * 首先建立一个教师类，其中要包括老师教的学生，和老师教的知识
 * 其次，老师要设置某节课要讲的知识，授课相当于通知学生“这些知识我讲了“
 * 然后，学生要学习知识
 * 上面两步就是消息之间的传递
 */
import java.util.ArrayList;
public class Teacher {
	private ArrayList<Student> students = new ArrayList<Student>();
	private int knowledge;
	public void setKnowledge(int knowledge) {
		//当知识点被老师讲出的时候，通知学生
		this.knowledge = knowledge;
		notifyAllMembers();
	}
	public void notifyAllMembers() {
		//老师告诉每一个学生该学习了
		for(Student student: students){
			student.learn();
		}
	}
	public int getKnowledge() {
		return knowledge;
	}
	public void append(Student student){
		students.add(student);
	}
}

//创建学生的抽象类，定义学生的学习行为
public abstract class Student {
	protected Teacher teacher;
	public abstract void learn();
}

//每个学生继承学生类，实现学习行为，并初始化学生的老师（想象成认老师，别走错班）
public class StudentTom extends Student {
	//构造函数，初始化Student抽象类中的teacher对象，并把StudentTom类加入到ArrayList里
	public StudentTom(Teacher teacher) {
		this.teacher = teacher;
		this.teacher.append(this);
	}
	@Override
	public void learn() {
		System.out.println("Tom第"+ teacher.getKnowledge() + "个知识已经学习");
	}
}
public class StudentJerry extends Student {
	//构造函数，初始化Student抽象类中的teacher对象，并把StudentJerry类加入到ArrayList里
	public StudentJerry(Teacher teacher) {
		this.teacher = teacher;
		this.teacher.append(this);
	}
	@Override
	public void learn() {
		System.out.println("Jerry第"+ teacher.getKnowledge() + "个知识已经学习");
	}
}
public class StudentJack extends Student {
	// 构造函数，初始化Student抽象类中的teacher对象，并把StudentJack类加入到ArrayList里
	public StudentJack(Teacher teacher) {
		this.teacher = teacher;
		this.teacher.append(this);
	}

	@Override
	public void learn() {
		System.out.println("Jack第" + teacher.getKnowledge() + "个知识已经学习");
	}
}

//主方法让实现整个过程，就像学校为老师和学生分配教学班
public class ObserverMode {
	public static void main(String[] args) {
		//创建一个教师对象
		Teacher teacher = new Teacher();
		//假设Tom，Jerry，Jack在一个班，被一个老师教学
		new StudentTom(teacher);
		new StudentJerry(teacher);
		new StudentJack(teacher);
		//观察学生是否学习到了知识
		teacher.setKnowledge(0);
		System.out.println("====================");
		teacher.setKnowledge(1);
		System.out.println("====================");
		teacher.setKnowledge(2);
	}
}

---

我总结优缺点再好，也不如菜鸟教程好，所以我把优缺点直接拿过来，进行讲解记录：

优点：

1. 观察者和被观察者是抽象耦合的。 （就是通过抽象类进行关联）
2. 建立一套触发机制。（在本例中，就是用setKnowledge并用notyfyAllMembers()。一旦触发到新知识，老师就会通知学生学习，这里的新旧不是传统意义的新旧，而是知识的初始化的过程。即一旦知识被初始化，就会通知学生）

缺点：

1.  如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。
2. 如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。 （所以耦合度越低越好，尽量减少类之间的关联）
3. 观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

提一个问题：java中的多线程用到的notifyAll()方法通知其他线程开始启动，是否是观察者模式？