观察者模式
观察者模式是为了满足监听的需求。也就是说当某件事情发生的时候， 一个或多个观察者需要获知此事件的发生， 如果每个观察者都采用轮询的方式判断事件是否发生，则会耗费较多的资源。所以这个任务就应该由被观察者来完成， 即被观察者持有多个观察者对象， 当自身某事件发生的时候， 去通知所有观察者。这样一种机制就是观察者模式。
但是这其中会有一些安全问题，比如说被观察者持有观察者对象，这时观察者就完全暴露给了被观察者，这种情况应该避免出现。所以就自然引出了接口的概念，以一个接口来统一观察者的行为， 被观察者只持有该接口， 任何一个实现了该接口的对象，都可以作为观察者被其持有， 而对象的其他细节则不对被观察者开放。
Java中已经封装了观察者模式，我们可以仿照它的写法来实现自己的观察者模式
首先， 由我们之前提到的， 观察者应该提供统一接口用来让被观察者调用，即：
Observer
public interface Observer {
void update(Observable observable, Object object);
}
对于观察者，则比较复杂， 我们可以找出几个主要的步骤：
| 序号 | 步骤 |
|---|---|
| 1 | 持有观察者 |
| 2 | 判断是否有改变 |
| 3 | 通知观察者 |
这样我们就可以写出被观察者的抽象类：
public abstract class Observable {
private Vector<Observer>observers = new Vector<>();
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标识符， 以线程安全的方式来通知观察者。但是这些在这里都不是重点，所以就不再详述</font>
下面看一个实际应用：
在我们的例子中，有一名学生和若干老师， 学生会提出一些问题，这些问题则会提交给老师（通知观察者），老师则判断自己是否会做，给学生反馈。>在这里我们有两位老师，一位是数学老师， 一位是美术老师， 目前的设定是他们每人只回答一个问题， 遇到其余的问题则会跳过 。
看一下具体代码：
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);
}
实际调用：
public class Client_Click {
public static void main(String[] args) {
TextView textView = new TextView();
textView.setOnClickListener(new OnClickListener() {
@Override
public void onClick(String view, int position) {
System.out.println(view);
System.out.println(position);
}
});
textView.click();
}
}
上面的代码已经比较清晰了， 应该可以理解回调的意义了
对于回调和观察者模式的联系和区别， 以及他们的适用环境，可以结合实际情况来判断。我打算过些日子有时间详细的写一下。
