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

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

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

。。。。。。

接下来，不得了了，众男们（假设现在有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();

}

}

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

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

作为女孩，首先我要知道谁喜欢我啊，不然通知错人了怎么办？（实际情况是，尽管你知道有人喜欢你，但是这个人是谁你知道吗？）
又有人喜欢女孩了，也想照顾她。但是不想让女孩知道，只想默默地付出。按照我们现在这种写法，只有女孩知道谁喜欢她才会通知到，不知道的就不通知了。
其他

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

看了我们上面的写法，发现这种写法是不合适的。我们有没有解决办法呢？
答案当然是有啊。但是首先我们应明确自己的需求。

我只要主动关注女孩就行了，不用等通知，自己要主动，毕竟幸福靠自己争取。
女孩魅力大，我们要允许其他人也喜欢（不限于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 boys;

public Girl(){
    boys = new ArrayList();
}

@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











 测试类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();
}
}









 结果：
  
result
 
 好了，到此我们观察者模式就简单地描述完了。回到开篇前我们的两个问题，我们现在这种模式有没有解决问题呢？
  作为女孩，首先我要知道谁喜欢我啊，不然通知错人了怎么办？（实际情况是，尽管你知道有人喜欢你，但是这个人是谁你知道吗？）
 
 我们现在在Girl（Subject实现类）中维护一个数组或者队列，用来保存观察者。并不需要知道观察者是谁。我们在创建Girl的时候将队列初始化（换句话说，我知道肯定有人喜欢我，但是具体是谁，我并不需要知道）。
  又有人喜欢女孩了，也想照顾她。但是不想让女孩知道，只想默默地付出。按照我们现在这种写法，只有女孩知道谁喜欢她才会通知到，不知道的就不通知了。
 
 现在即便是有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










 Observer 









public interface Observer {

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

}










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