设计模式学习之Observer模式

• 今天继续学习设计模式。
  学到的两个模式：观察者模式，它属于行为性模式。

• 观察者模式：
  定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。
• 适用性：
1. 当一个抽象模型有两个方面, 其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。
2. 当对一个对象的改变需要同时改变其它对象, 而不知道具体有多少对象有待改变。
3. 当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换言之, 你不希望这些对象是紧密耦合的。

• 我的理解是：
  观察者模式首先定义了一个被观察者，然后让很多的观察者订阅被观察者，而被观察者在自己的状态有了更新时向所有的观察者“推送”自己的状态信息，从而使所有的观察者都得到通知。其实这个模式让人很容易想到当前一种最为潮流的互联网应用：微博。就拿微博为例，每一个人都可以是观察者与被观察者两种身份，当你关注别人的时候，比如你的一个朋友小罗，你就成为了小罗的粉丝，就相当于此时小罗为被观察者，而你自己是观察者身份，你订阅了被观察者，使被观察者在自己状态发生改变时会及时通知你。比如小罗今天去旅游，他将照片发到了微博上，这样你就能及时的看到他的动态了。而且不只是你，他所有的粉丝都能看到他的动态了。而当你的另外一个朋友，比如小杨关注了你，这样你就成为了被观察者，而小杨就是观察者，当你在微博上的个人中心上发状态时，小杨就能实时看到你的状态了，或者会对你的状态进行评论。所以，Observer模式很容易理解。
  那么，如何来实现它呢？其实很简单，主要是在被观察者上面做文章，被观察者类需要引入三个方法：AddObserver, DeleteObserver, Notify。
  前两个方法用来动态的增加和删除观察者，后面一个方法用来通知所有的观察者。
• 代码：

• //被观察者接口
  public interface IObservarable
  {
    public void addObserver(Observer obs);
    public void deleteObserver(Observer obs);
    public void notify();
  }
  //被观察者类
  public class Observarable implements IObserverable
  {
    protected ArrayList arrObservers;//存放所有的观察者
    protected ArrayList arrStates;//存放自己的状态以便通知所有的观察者
    protected String name;
    public Observarable(String name)
    {
      this.name=name;
      this.arrObservers=new ArrayList();
    }
    public void addObserver(Observer obs)
    {
      arrObservers.add(obs);
    }
    public void deleteObserver(Observer obs)
    {
      int i=this.arrObservers.indexof(obs);
      if(i>=0)
      {
        this.arrObservers.remove(i);
      }
    }
    public void notify()
    {
      this.arrStates=new ArrayList();
      this.arrStates.add(this.name);
      for(int i=0; i<this.arrObservers.size(); i++)
      {
        Observer obs=arrObservers.get(i);
        obs.update(this, this.arrStates);
      }
    }
    public string getName()
    {
      return this.name;
    }
  }
  //更加具体的被观察者（拥有自己的状态）
  public class Observerable1 extends Observable
  {
    private State1 state1;
    private State2 state2;
    public void notify()
    {
      this.arrStates.add(this.name);
      this.arrStates.add(this.state1);
      this.arrStates.add(this.state2);
      for(int i=0; i<this.arrObservers.size(); i++)
      {
        Observer obs=arrObservers.get(i);
        obs.update(this, arrStates);
      }
    }
    public State1 getState1()
    {
      return this.state1;
    }
    public State2 getState2()
    {
      return this.state2;
    }  
  }
  //观察者接口
  public interface IObserver
  {
    public void update(Observerable o, Object arg);
  }
  //观察者类
  public class Observer implements IObserver
  {
    protected String name;
    public Observer(String name)
    {
      this.name=name;
    }
    public void update(Observerable o, Object arg)
    {
      System.out.println("Observer "+this.name+" has been notified!");
    }
  }
  //更加具体的观察者1（采用拉的方式）
  public class Observer1 extends Observer
  {
    public void update(Observerable o, Object arg)
    {
      super.update();
      System.out.println("I love you!");
      System.out.println("I have get the state of "+o.getName());
      if(o instanceof Observerable1)
      {
        System.out.println("state1:"+o.getState1()+", state2:"+o.getState2());
      }
    }
  }
  //更加具体的观察者2（采用推的方式）
  public class Observer2 extends Observer
  {
    public void update(Observerable o, Object arg)
    {
      super.update();
      System.out.println("I love you!");  
      if(o instanceof Observerable1)
      {
        System.out.println("I have get the state of "+arg[0].toString());
        System.out.println("state1:"+(State1)arg[1].toString()+", state2:"+(State2)arg[2].toString());
      }
    }
  }
  public class Test
  {
    public static void main(string []argv)
    {
      Observer1 obs1=new Observer1("xiaoluo");
      Observer1 obs2=new Observer2("xiaoyang");
      Observerable1 obsb1=new Observerable1("xiaoguo");
      obsb1.addObserver(obs1);
      obsb1.addObserver(obs2);
      obsb1.notify();
    }
  }