观察者模式（新手推荐）

今天给大家带来一个较为简单的模式，观察者模式。如果觉得我写得还不错，记得关注下，我好有勇气给大家以浅显的语言介绍完这几种设计模式（觉得写得还不错的记得关注下，我好继续给大家更新，平时上班很忙的）。

为什么要使用观察者模式？

举个简单的例子，在一所工科学校里（我们都知道，工科院校女生都比较少），有一个很有教养，漂亮，温柔的女生大家都很喜欢，自然有很多人追。女生的一举一动，大家都很关注。比如女生半夜发了个状态，说“我饿了”。

。。。。。。

接下来，不得了了，众男们（假设现在有A,B,C三个男生同时喜欢上了改女生）着急了，都想用自己的方法让女生填饱肚子（A：走，带你吃KFC。B：别动，我给你买了送到你楼下。C：自己画个饼，看看就行了）。当然以C的这种方式，肯定没戏，咳咳，扯远了。那么用伪代码如何表示呢？

abstract class Boy{

//照顾自己身边的人是每个男生义不容辞的责任

pulbic void careDarling();

}

// A 照顾人的方式

class BoyA extends Boy{

pulbic void careDarling(){

   System.out.println("走，带你吃KFC");

}

}

//B 照顾人的方式

class BoyB extends Boy{

pulbic void careDarling(){

   System.out.println("别动，我给你买了送到你楼下");

}

}

//C 照顾人的方式

class BoyC extends Boy{

pulbic void careDarling(){

   System.out.println("自己画个饼，看看就行了");

}

}

//下面这个是女孩类

class Girl{

public void hungrey(){

   //饿了，我们要通知A，B，C 是时候行动了    

   BoyA.careDarling();

   BoyB.careDarling();

   BoyC.careDarling();

}

}

当然，我们尊重每个人爱人的方式。现在不是纠结这个的时候，我们看上面伪代码的表示有什么问题吗？

就在下看，有发现几个问题：

1. 作为女孩，首先我要知道谁喜欢我啊，不然通知错人了怎么办？（实际情况是，尽管你知道有人喜欢你，但是这个人是谁你知道吗？）

2. 又有人喜欢女孩了，也想照顾她。但是不想让女孩知道，只想默默地付出。按照我们现在这种写法，只有女孩知道谁喜欢她才会通知到，不知道的就不通知了。

3. 其他

使用观察者模式有什么好处

看了我们上面的写法，发现这种写法是不合适的。我们有没有解决办法呢？ 

答案当然是有啊。但是首先我们应明确自己的需求。

1. 我只要主动关注女孩就行了，不用等通知，自己要主动，毕竟幸福靠自己争取。

2. 女孩魅力大，我们要允许其他人也喜欢（不限于A,B,C）,毕竟每个人都有爱与被爱的权利。

所以，观察者模式来救场。

（声明下，我有空了就去学UML。这个画的不够标准，希望能说明问题。）

那么对应于我们这个例子，之间关系又是怎样的呢？

那我们为何不用代码实现下呢？

Observer

public interface Observer {

public void update();

}

Boy

public abstract class Boy {

public abstract void careDarling();

}

BoyA

public class BoyA extends Boy implements Observer {

private Subject subject;

public BoyA(Subject subject){

   subject.addObserver(this);

}

@Override

public void update() {

   careDarling();

}

@Override

public void careDarling() {

   System.out.println("走，带你吃KFC");

}

}

BoyB

public class BoyB extends Boy implements Observer {

private Subject subject;

public BoyB(Subject subject){

   subject.addObserver(this);

}

@Override

public void update() {

   careDarling();

}

@Override

public void careDarling() {

   System.out.println("别动，我给你买了送到你楼下");

}

}

BoyC

public class BoyC extends Boy implements Observer {

private Subject subject;

public BoyC(Subject subject){

   subject.addObserver(this);

}

@Override

public void update() {

   careDarling();

}

@Override

public void careDarling() {

   System.out.println("自己画个饼，看看就行了");

}

}

Subject

public interface Subject {

public void addObserver(Observer boy);

public void removeObserver(Observer boy);

public void notifyObservers();    

}

Girl

public class Girl implements Subject {

private List<Observer> boys;

public Girl(){

   boys = new ArrayList<Observer>();

}

@Override

public void addObserver(Observer boy) {

   boys.add(boy);

}

@Override

public void removeObserver(Observer boy) {

   boys.remove(boy);

}

@Override

public void notifyObservers() {

   for(int i=0;i<boys.size();i++){

       boys.get(i).update();

   }

}

public void hungrey(){

   notifyObservers();

}

}

测试类ObserverTest

public class ObserverTest {

public static void main(String[] args) {

   //小天使来到世界上

   Girl girl = new Girl();

   //护花使者A

   BoyA boyA = new BoyA(girl);

   //护花使者B

   BoyB boyB = new BoyB(girl);

   //护花使者C

   BoyC boyC = new BoyC(girl);

   //出大事了，小可爱饿了

   girl.hungrey();

}

}

结果：

好了，到此我们观察者模式就简单地描述完了。回到开篇前我们的两个问题，我们现在这种模式有没有解决问题呢？ 

1. 作为女孩，首先我要知道谁喜欢我啊，不然通知错人了怎么办？（实际情况是，尽管你知道有人喜欢你，但是这个人是谁你知道吗？）

我们现在在Girl（Subject实现类）中维护一个数组或者队列，用来保存观察者。并不需要知道观察者是谁。我们在创建Girl的时候将队列初始化（换句话说，我知道肯定有人喜欢我，但是具体是谁，我并不需要知道）。

1. 又有人喜欢女孩了，也想照顾她。但是不想让女孩知道，只想默默地付出。按照我们现在这种写法，只有女孩知道谁喜欢她才会通知到，不知道的就不通知了。

现在即便是有BoyC，BoyD出现，在创建的时候就自己偷偷关注了女孩，当女孩饿了的时候，并不需要改变原有的代码就可实现通知所有的。（多好，我们的这种实现方式。毕竟暗恋也是美好的）。

然而在实际中，主题Subject在通知观察者Observer的时候会携带一些数据，这就不得不提一下观察者模式的两种模式：推（push）模式和拉(pull)模式。

推模型：顾名思义，就是我不管你Observer想要什么，我给你什么你接收什么就是了。这种模式的使用场景就是需求较简单，且Subject和Observer类协商好返回数据的类型。弊端当然也很明显就是众Observer口难调，我不知道你想要什么，大家返回都一样。可以想象成任性的女孩，我给你什么你要也得接受，不要也得接受。

全写的话量有点大，所以只贴部分代码：

public interface Subject {

public void addObserver(Observer boy);

public void removeObserver(Observer boy);

public void notifyObservers(int state)；

}

可以看出，这个地方我们将state作为参数传出去，然后在Observer中被动接收。

public interface Observer {

public void update(int state);

//举个例子，这时候我们就可以在BoyA，BoyB...等中针对具体状态作出相应动作。比如饿了怎么样，困了怎么样......

}

拉模型：就是观察者（Observer）自己站起来了，想要什么就给什么。一般我们把主题类该类对象作为参数传递出去，然后观察者可以利用反射等方式拿到自己想要的，推模型的问题解决了，大家(众多观察者)可以各取所需。可以这么理解，付出这么多，女孩追到手了，把自己都交给你了。

public interface Subject {

public void addObserver(Observer boy);

public void removeObserver(Observer boy);

public void notifyObservers(Subject subject)；

}

Girl

...

@Override

public void notifyObservers(Subject subject) {

   for(int i=0;i<boys.size();i++){

       boys.get(i).update(subject);

   }

}

public void hungrey(){

   notifyObservers(this);//将自己传出去

}

...

Observer

public interface Observer {

public void update(Subject subject);//人都得到了，想知道什么还难吗？

}

好了，观察者模式到此介绍完毕，大家有什么问题可以与我讨论。当然文中错误在所难免，恳请批评指正。