回调与观察者模式

###观察者模式

观察者模式是为了满足监听的需求。也就是说当某件事情发生的时候， 一个或多个观察者需要获知此事件的发生， 如果每个观察者都采用轮询的方式判断事件是否发生，则会耗费较多的资源。所以这个任务就应该由被观察者来完成， 即被观察者持有多个观察者对象， 当自身某事件发生的时候， 去通知所有观察者。这样一种机制就是观察者模式。

但是这其中会有一些安全问题，比如说被观察者持有观察者对象，这时观察者就完全暴露给了被观察者，这种情况应该避免出现。所以就自然引出了接口的概念，以一个接口来统一观察者的行为， 被观察者只持有该接口， 任何一个实现了该接口的对象，都可以作为观察者被其持有， 而对象的其他细节则不对被观察者开放。

Java中已经封装了观察者模式，我们可以仿照它的写法来实现自己的观察者模式

首先， 由我们之前提到的， 观察者应该提供统一接口用来让被观察者调用，即：

Observer

public interface Observer {
	void update(Observable observable, Object object);
}

对于观察者，则比较复杂， 我们可以找出几个主要的步骤：

序号	步骤
1	持有观察者
2	判断是否有改变
3	通知观察者

这样我们就可以写出被观察者的抽象类：

public abstract class Observable {
	private List<Observer>observers = new ArrayList<>();
	private boolean isChanged;
	public void addObserver(Observer observer){
		observers.add(observer);
	}
	public void setChanged(){
		isChanged = true;
	}
	public void notifyObservers(Object object){
		if (isChanged) {
			observers.forEach(observer -> observer.update(this, object));
			isChanged = false;
		}
	}
}

这样我们就定义了观察者的接口，以及被观察者的抽象类

其实，在jdk的实现中，Observable 会有完善的线程安全保护， 比如存放观察者的List是以Vector来实现的，而Vector本身就是线程安全的， 再比如Observable 中的方法都加上了synchronize标识符， 以线程安全的方式来通知观察者。但是这些在这里都不是重点，所以就不再详述

下面看一个实际应用：

在我们的例子中，有一名学生和若干老师， 学生会提出一些问题，这些问题则会提交给老师（通知观察者），老师则判断自己是否会做，给学生反馈。
在这里我们有两位老师，一位是数学老师， 一位是美术老师， 目前的设定是他们每人只回答一个问题， 遇到其余的问题则会跳过 。

看一下具体代码：

Tea_Math

public class Tea_Math implements Observer{
	private String name = "数学老师：";
	@Override
	public void update(Observable observable, Object object) {
		String question = (String) object;
		if(question.equals("矩阵相乘的意义是什么呢？")){
			System.out.println(name +"从某种角度来说， 是坐标的变换");
		}else {
			System.out.println(name +"我不太清楚， 你问问其他老师");
		}
	}
}

Tea_Art

public class Tea_Art implements Observer{
	private String name = "美术老师：";
	@Override
	public void update(Observable observable, Object object) {
		String question = (String) object;
		if(question.equals("莫奈的睡莲是他晚年的作品吗？")){
			System.out.println(name +"是他晚年一系列的作品");
		}else {
			System.out.println(name +"我不太清楚， 你问问其他老师");
		}
	}
}

Stu

public class Stu extends Observable{
	public void ask(String question){
		System.out.println("question:" + question);
		setChanged();
		notifyObservers(question);
	}
}

实际调用：

public class Client {
	public static void main(String[] args) {
		Stu stu = new Stu();
		Tea_Math tea_Math = new Tea_Math();
		Tea_Art tea_Art = new Tea_Art();
		
		stu.addObserver(tea_Math);
		stu.addObserver(tea_Art);
		
		stu.ask("矩阵相乘的意义是什么呢？");
		stu.ask("莫奈的睡莲是他晚年的作品吗？");
	}
}

我们可以看一下运行结果：

question:矩阵相乘的意义是什么呢？

数学老师：从某种角度来说， 是坐标的变换
美术老师：我不太清楚， 你问问其他老师

question:莫奈的睡莲是他晚年的作品吗？

数学老师：我不太清楚， 你问问其他老师
美术老师：是他晚年一系列的作品

以上就是观察者模式的说明以及代码实现，应该是比较清晰的。

###回调：
回调是则是为了满足调用者的需求而设计的。如调用者需要执行某个动作， 并且它要自己定义完成该动作后该做什么工作。这个时候该动作是调用者自己发出的， 但是这个动作的完成需要交由被调用者来实现， 这样的话， 调用者该如何知道完成该动作后接下来做什么呢？它怎么才能知道调用者定义的后续工作呢？这时候就需要用到回调， 要实现一个回调的基本步骤有：

序号	步骤
1	调用者定义某个动作
2	然后指定执行该动作的被调用者（持有被调用者）
3	再定义动作完成后需要执行的后续动作
4	最后将这个后续动作告知被调用者（或者可以说将这个后续动作的调用方法交给被调用者）。通常情况下， 被调用者是系统应用， 也就是说， 我们将自己的后续动作告知系统应用， 让其完成后执行我们的操作。

可以用点击事件的实现来深入一下：

如有一个TextView作为调用者， 一个OnClickListener作为被调用者

TextView应该持有OnClickListener， 所以它有一个setOnClickListener方法

而且它要执行onClick动作，所以它有click方法。

而对于被调用者OnClickListener来说，
它是click动作的实际完成者，所以它有onClick方法。

这样的话就可以写出二者的结构：

TextView

public class TextView {
//持有被调用者
private OnClickListener onClickListener;

public void setOnClickListener(OnClickListener onClickListener){
	this.onClickListener = onClickListener;
}

public void click(){
	onClickListener.onClick("textview", 1);
}

OnClickListener

public interface OnClickListener {
void onClick(String view, int position);
}

实际调用Client：

public class Client_Click {

public static void main(String[] args) {
	TextView textView = new TextView();
	//内部类，指定被调用者
	//此时， OnClickListener可以看做系统应用， 我们将自已的后续动作告知系统应用， 让它调用
	textView.setOnClickListener(new OnClickListener() {
		
		@Override
		public void onClick(String view, int position) {
			
			定义后续动作
			System.out.println(view);
			System.out.println(position);
		}
	});
	textView.click();
}
}

上面的代码已经比较清晰了， 应该可以理解回调的意义了

对于回调和观察者模式的联系和区别， 简单来说，就是回调是观察者模式的特例，只有一个观察者